discolike-cli 0.3.0__tar.gz → 0.3.2__tar.gz

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: discolike-cli
-Version: 0.3.0
+Version: 0.3.2
 Summary: Official CLI for the DiscoLike API
 Project-URL: Homepage, https://www.discolike.com
 Project-URL: Documentation, https://docs.discolike.com
@@ -25,7 +25,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: discolike==0.3.0
+Requires-Dist: discolike==0.3.2
 Requires-Dist: rich>=13.0
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "discolike-cli"
-version = "0.3.0"
+version = "0.3.2"
 description = "Official CLI for the DiscoLike API"
 readme = "README.md"
 license = "MIT"
@@ -12,7 +12,7 @@ license-files = ["LICENSE"]
 requires-python = ">=3.10"
 authors = [{ name = "DiscoLike", email = "support@discolike.com" }]
 dependencies = [
-  "discolike==0.3.0",
+  "discolike==0.3.2",
   "typer>=0.12",
   "rich>=13.0",
 ]

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/src/discolike_cli/auth.py

@@ -33,11 +33,12 @@ from discolike._oauth import OAuthError
 from discolike._oauth import build_authorization_url
 from discolike._oauth import discover
 from discolike._oauth import exchange_code
-from discolike._oauth import pkce_pair
 from discolike._oauth import register_client
 from discolike_cli._loopback import CallbackServer
 from discolike_cli._output import emit
 from discolike_cli._output import handle_errors
+from discolike_cli.signup import _is_interactive
+from discolike_cli.signup import run_signup
 
 app = typer.Typer(help="Manage credentials: log in (browser or API key), check status, log out.")
 
@@ -55,6 +56,10 @@ LOGIN_METHODS = (AUTH_METHOD_OAUTH, AUTH_METHOD_API_KEY)
 DEAD_CLIENT_ERRORS = frozenset({"invalid_client", "unauthorized_client"})
 
 
+HAS_ACCOUNT_PROMPT = "Do you already have a DiscoLike account?"
+SIGNUP_FOLLOWUP_MESSAGE = "Confirm the email, then run `discolike auth login` again to sign in."
+
+
 class _DeadClientError(Exception):
     """The authorization server no longer recognises the registered client_id."""
 
@@ -63,6 +68,23 @@ def _mask(key: str) -> str:
     return "…" + key[-MASKED_VISIBLE_CHARS:]
 
 
+def _was_passed_on_command_line(ctx: typer.Context, name: str) -> bool:
+    source = ctx.get_parameter_source(name)
+    return source is not None and source.name == "COMMANDLINE"
+
+
+def _offer_signup(ctx: typer.Context) -> None:
+    email = typer.prompt("Work email")
+    first_name = typer.prompt("First name")
+    last_name = typer.prompt("Last name")
+    base_url = str(ctx.obj.get("base_url") or DEFAULT_BASE_URL).rstrip("/")
+    run_signup(
+        email=email, first_name=first_name, last_name=last_name, agent=None, base_url=base_url, yes=False, fmt=None
+    )
+    typer.echo(SIGNUP_FOLLOWUP_MESSAGE)
+    raise typer.Exit(code=0)
+
+
 def _iso(epoch_seconds: float) -> str:
     return datetime.fromtimestamp(epoch_seconds, tz=timezone.utc).isoformat()
 
@@ -135,13 +157,11 @@ def _authorize(
     open_browser: bool,
     http: httpx2.Client,
 ) -> OAuthCredential:
-    verifier, challenge = pkce_pair()
     state = secrets.token_urlsafe(STATE_BYTES)
-    url = build_authorization_url(
+    url, verifier = build_authorization_url(
         metadata,
         client_id=registration.client_id,
         redirect_uri=registration.redirect_uri,
-        code_challenge=challenge,
         state=state,
         resource=resource,
     )
@@ -168,7 +188,6 @@ def _authorize(
             code_verifier=verifier,
             redirect_uri=registration.redirect_uri,
             resource=resource,
-            client=http,
         )
     except OAuthError as exc:
         if exc.error in DEAD_CLIENT_ERRORS:
@@ -230,6 +249,14 @@ def login(
     if method not in LOGIN_METHODS:
         raise typer.BadParameter(f"must be one of {', '.join(LOGIN_METHODS)}", param_hint="--method")
     global_key_passed = ctx.obj.get("api_key") is not None and _global_key_source(ctx) == SOURCE_OPTION
+    if (
+        _is_interactive()
+        and api_key is None
+        and not global_key_passed
+        and not _was_passed_on_command_line(ctx, "method")
+        and not typer.confirm(HAS_ACCOUNT_PROMPT, default=True)
+    ):
+        _offer_signup(ctx)
     if api_key or global_key_passed or method == AUTH_METHOD_API_KEY:
         _api_key_login(ctx, api_key=api_key)
         return

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/src/discolike_cli/company.py

@@ -134,12 +134,17 @@ def public_links(
 @handle_errors
 def extract_command(
     ctx: typer.Context,
-    url: str = typer.Argument(..., help="Page URL to extract content from"),
+    url: str | None = typer.Argument(None, help="Page URL to extract content from"),
+    domain: str | None = typer.Option(
+        None, "--domain", help="Bare domain to extract instead of URL (alias for https://DOMAIN, served from cache)."
+    ),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
 ) -> None:
-    """Extract page content from a URL."""
+    """Extract page content from a URL or a bare domain."""
     from discolike_cli.main import get_client
 
-    emit(
-        get_client(ctx).companies.extract(build_request(CompaniesExtractParams, _merge_params(None, url=url))), fmt=fmt
-    )
+    if (url is None) == (domain is None):
+        raise typer.BadParameter("Provide exactly one of URL or --domain")
+
+    request = build_request(CompaniesExtractParams, _merge_params(None, url=url, domain=domain))
+    emit(get_client(ctx).companies.extract(request), fmt=fmt)

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/src/discolike_cli/contacts.py

@@ -25,6 +25,25 @@ WAIT_HELP = "Block until the job finishes, streaming progress to stderr."
 TIMEOUT_HELP = "Max seconds to wait with --wait."
 PARAM_HELP = "Extra key=value query parameter forwarded to the SDK (repeatable)."
 JOBSTART_DATE_HELP = "Job start date filter: min date or 'min,max' range, e.g. 2025-01-01 or 2025-01-01,2025-06-30."
+SUMMARY_HELP = "Filter by profile summary text (semantic search)."
+NEGATE_SUMMARY_HELP = "Exclude contacts matching this summary description."
+NAME_HELP = "Filter by contact name (partial match supported)."
+SKILLS_HELP = "Filter by skill (repeatable)."
+FILTER_STATE_HELP = "Filter by company state/region (repeatable)."
+NEGATE_FILTER_STATE_HELP = "Exclude contacts at companies in this state (repeatable)."
+PERSON_STATE_HELP = "Filter by contact state/region (repeatable)."
+PERSONA_ID_HELP = "Filter by persona ID (repeatable)."
+EMAIL_VALIDATED_HELP = "Only contacts with (or without) a validated email address."
+HAS_PHONE_HELP = "Only contacts with (or without) a phone number."
+HAS_MOBILE_HELP = "Only contacts with (or without) a mobile phone number."
+HAS_LINKEDIN_HELP = "Only contacts with (or without) a LinkedIn profile."
+MIN_CONNECTIONS_HELP = "Minimum LinkedIn connections required."
+INCLUSION_QUERY_ID_HELP = "Include only contacts from companies in this saved query (repeatable)."
+EXCLUSION_QUERY_ID_HELP = "Exclude contacts from companies in this saved query (repeatable)."
+MAX_COMPANIES_HELP = "Maximum number of enriched companies to return; cannot be combined with --max-records."
+RESULTS_BY_COMPANY_HELP = "Maximum contacts per company domain (default 5; 0 removes the cap)."
+INCLUDE_SEARCH_CONTACTS_HELP = "Include contacts from the search index (broader coverage)."
+CONSENSUS_HELP = "Number of query vectors to combine for consensus search."
 
 app = typer.Typer(
     help="Find contacts: search and count by filters, look up or match individuals, and run bulk/generative discovery jobs."
@@ -42,20 +61,43 @@ def search_command(
     negate_department: list[str] | None = typer.Option(None, help="Exclude departments (repeatable)."),
     title: list[str] | None = typer.Option(None, help="Filter by job title (repeatable)."),
     negate_title: list[str] | None = typer.Option(None, help="Exclude job titles (repeatable)."),
+    name: str | None = typer.Option(None, help=NAME_HELP),
+    summary: str | None = typer.Option(None, help=SUMMARY_HELP),
+    negate_summary: str | None = typer.Option(None, help=NEGATE_SUMMARY_HELP),
+    skills: list[str] | None = typer.Option(None, help=SKILLS_HELP),
     domain: list[str] | None = typer.Option(None, help="Filter by company domain (repeatable)."),
     person_country: list[str] | None = typer.Option(None, help="Filter by contact country (repeatable)."),
     negate_person_country: list[str] | None = typer.Option(None, help="Exclude contact countries (repeatable)."),
+    person_state: list[str] | None = typer.Option(None, help=PERSON_STATE_HELP),
+    persona_id: list[int] | None = typer.Option(None, help=PERSONA_ID_HELP),
     filter_industry: list[str] | None = typer.Option(None, help="Filter by company industry (repeatable)."),
     negate_filter_industry: list[str] | None = typer.Option(None, help="Exclude company industries (repeatable)."),
     filter_country: list[str] | None = typer.Option(None, help="Filter by company country (repeatable)."),
     negate_filter_country: list[str] | None = typer.Option(None, help="Exclude company countries (repeatable)."),
+    filter_state: list[str] | None = typer.Option(None, help=FILTER_STATE_HELP),
+    negate_filter_state: list[str] | None = typer.Option(None, help=NEGATE_FILTER_STATE_HELP),
     employee_range: str | None = typer.Option(None, help="Company employee range, e.g. 50-200."),
     has_email: bool | None = typer.Option(
         None, "--has-email/--no-has-email", help="Only contacts with (or without) an email address."
     ),
+    email_validated: bool | None = typer.Option(
+        None, "--email-validated/--no-email-validated", help=EMAIL_VALIDATED_HELP
+    ),
+    has_phone: bool | None = typer.Option(None, "--has-phone/--no-has-phone", help=HAS_PHONE_HELP),
+    has_mobile: bool | None = typer.Option(None, "--has-mobile/--no-has-mobile", help=HAS_MOBILE_HELP),
+    has_linkedin: bool | None = typer.Option(None, "--has-linkedin/--no-has-linkedin", help=HAS_LINKEDIN_HELP),
+    min_connections: int | None = typer.Option(None, help=MIN_CONNECTIONS_HELP),
     jobstart_date: str | None = typer.Option(None, "--jobstart-date", help=JOBSTART_DATE_HELP),
+    inclusion_query_id: list[str] | None = typer.Option(None, help=INCLUSION_QUERY_ID_HELP),
+    exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
     max_records: int | None = typer.Option(None, help="Maximum number of contacts to return."),
+    max_companies: int | None = typer.Option(None, help=MAX_COMPANIES_HELP),
     offset: int | None = typer.Option(None, help="Number of records to skip for pagination."),
+    results_by_company: int | None = typer.Option(None, help=RESULTS_BY_COMPANY_HELP),
+    include_search_contacts: bool | None = typer.Option(
+        None, "--include-search-contacts/--no-include-search-contacts", help=INCLUDE_SEARCH_CONTACTS_HELP
+    ),
+    consensus: int | None = typer.Option(None, help=CONSENSUS_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
     param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
 ) -> None:
@@ -71,18 +113,37 @@ def search_command(
         negate_department=negate_department,
         title=title,
         negate_title=negate_title,
+        name=name,
+        summary=summary,
+        negate_summary=negate_summary,
+        skills=skills,
         domain=domain,
         person_country=person_country,
         negate_person_country=negate_person_country,
+        person_state=person_state,
+        persona_id=persona_id,
         filter_industry=filter_industry,
         negate_filter_industry=negate_filter_industry,
         filter_country=filter_country,
         negate_filter_country=negate_filter_country,
+        filter_state=filter_state,
+        negate_filter_state=negate_filter_state,
         employee_range=employee_range,
         has_email=has_email,
+        email_validated=email_validated,
+        has_phone=has_phone,
+        has_mobile=has_mobile,
+        has_linkedin=has_linkedin,
+        min_connections=min_connections,
         jobstart_date=jobstart_date,
+        inclusion_query_id=inclusion_query_id,
+        exclusion_query_id=exclusion_query_id,
         max_records=max_records,
+        max_companies=max_companies,
         offset=offset,
+        results_by_company=results_by_company,
+        include_search_contacts=include_search_contacts,
+        consensus=consensus,
     )
     emit(get_client(ctx).contacts.search(build_request(ContactsSearchParams, kwargs)), fmt=fmt)
 
@@ -98,18 +159,43 @@ def count_command(
     negate_department: list[str] | None = typer.Option(None, help="Exclude departments (repeatable)."),
     title: list[str] | None = typer.Option(None, help="Filter by job title (repeatable)."),
     negate_title: list[str] | None = typer.Option(None, help="Exclude job titles (repeatable)."),
+    name: str | None = typer.Option(None, help=NAME_HELP),
+    summary: str | None = typer.Option(None, help=SUMMARY_HELP),
+    negate_summary: str | None = typer.Option(None, help=NEGATE_SUMMARY_HELP),
+    skills: list[str] | None = typer.Option(None, help=SKILLS_HELP),
     domain: list[str] | None = typer.Option(None, help="Filter by company domain (repeatable)."),
     person_country: list[str] | None = typer.Option(None, help="Filter by contact country (repeatable)."),
     negate_person_country: list[str] | None = typer.Option(None, help="Exclude contact countries (repeatable)."),
+    person_state: list[str] | None = typer.Option(None, help=PERSON_STATE_HELP),
+    persona_id: list[int] | None = typer.Option(None, help=PERSONA_ID_HELP),
     filter_industry: list[str] | None = typer.Option(None, help="Filter by company industry (repeatable)."),
     negate_filter_industry: list[str] | None = typer.Option(None, help="Exclude company industries (repeatable)."),
     filter_country: list[str] | None = typer.Option(None, help="Filter by company country (repeatable)."),
     negate_filter_country: list[str] | None = typer.Option(None, help="Exclude company countries (repeatable)."),
+    filter_state: list[str] | None = typer.Option(None, help=FILTER_STATE_HELP),
+    negate_filter_state: list[str] | None = typer.Option(None, help=NEGATE_FILTER_STATE_HELP),
     employee_range: str | None = typer.Option(None, help="Company employee range, e.g. 50-200."),
     has_email: bool | None = typer.Option(
         None, "--has-email/--no-has-email", help="Only contacts with (or without) an email address."
     ),
+    email_validated: bool | None = typer.Option(
+        None, "--email-validated/--no-email-validated", help=EMAIL_VALIDATED_HELP
+    ),
+    has_phone: bool | None = typer.Option(None, "--has-phone/--no-has-phone", help=HAS_PHONE_HELP),
+    has_mobile: bool | None = typer.Option(None, "--has-mobile/--no-has-mobile", help=HAS_MOBILE_HELP),
+    has_linkedin: bool | None = typer.Option(None, "--has-linkedin/--no-has-linkedin", help=HAS_LINKEDIN_HELP),
+    min_connections: int | None = typer.Option(None, help=MIN_CONNECTIONS_HELP),
     jobstart_date: str | None = typer.Option(None, "--jobstart-date", help=JOBSTART_DATE_HELP),
+    inclusion_query_id: list[str] | None = typer.Option(None, help=INCLUSION_QUERY_ID_HELP),
+    exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
+    max_records: int | None = typer.Option(None, help="Maximum number of contacts to count (20-10000)."),
+    max_companies: int | None = typer.Option(None, help=MAX_COMPANIES_HELP),
+    offset: int | None = typer.Option(None, help="Number of records to skip for pagination."),
+    results_by_company: int | None = typer.Option(None, help=RESULTS_BY_COMPANY_HELP),
+    include_search_contacts: bool | None = typer.Option(
+        None, "--include-search-contacts/--no-include-search-contacts", help=INCLUDE_SEARCH_CONTACTS_HELP
+    ),
+    consensus: int | None = typer.Option(None, help=CONSENSUS_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
     param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
 ) -> None:
@@ -125,16 +211,37 @@ def count_command(
         negate_department=negate_department,
         title=title,
         negate_title=negate_title,
+        name=name,
+        summary=summary,
+        negate_summary=negate_summary,
+        skills=skills,
         domain=domain,
         person_country=person_country,
         negate_person_country=negate_person_country,
+        person_state=person_state,
+        persona_id=persona_id,
         filter_industry=filter_industry,
         negate_filter_industry=negate_filter_industry,
         filter_country=filter_country,
         negate_filter_country=negate_filter_country,
+        filter_state=filter_state,
+        negate_filter_state=negate_filter_state,
         employee_range=employee_range,
         has_email=has_email,
+        email_validated=email_validated,
+        has_phone=has_phone,
+        has_mobile=has_mobile,
+        has_linkedin=has_linkedin,
+        min_connections=min_connections,
         jobstart_date=jobstart_date,
+        inclusion_query_id=inclusion_query_id,
+        exclusion_query_id=exclusion_query_id,
+        max_records=max_records,
+        max_companies=max_companies,
+        offset=offset,
+        results_by_company=results_by_company,
+        include_search_contacts=include_search_contacts,
+        consensus=consensus,
     )
     emit(get_client(ctx).contacts.count(build_request(ContactsCountParams, kwargs)), fmt=fmt)
 
@@ -220,19 +327,37 @@ def discover_command(
     negate_department: list[str] | None = typer.Option(None, help="Exclude departments (repeatable)."),
     title: list[str] | None = typer.Option(None, help="Filter by job title (repeatable)."),
     negate_title: list[str] | None = typer.Option(None, help="Exclude job titles (repeatable)."),
+    name: str | None = typer.Option(None, help=NAME_HELP),
+    summary: str | None = typer.Option(None, help=SUMMARY_HELP),
+    negate_summary: str | None = typer.Option(None, help=NEGATE_SUMMARY_HELP),
+    skills: list[str] | None = typer.Option(None, help=SKILLS_HELP),
     domain: list[str] | None = typer.Option(None, help="Filter by company domain (repeatable)."),
     person_country: list[str] | None = typer.Option(None, help="Filter by contact country (repeatable)."),
     negate_person_country: list[str] | None = typer.Option(None, help="Exclude contact countries (repeatable)."),
+    person_state: list[str] | None = typer.Option(None, help=PERSON_STATE_HELP),
+    persona_id: list[int] | None = typer.Option(None, help=PERSONA_ID_HELP),
     filter_industry: list[str] | None = typer.Option(None, help="Filter by company industry (repeatable)."),
     negate_filter_industry: list[str] | None = typer.Option(None, help="Exclude company industries (repeatable)."),
     filter_country: list[str] | None = typer.Option(None, help="Filter by company country (repeatable)."),
     negate_filter_country: list[str] | None = typer.Option(None, help="Exclude company countries (repeatable)."),
+    filter_state: list[str] | None = typer.Option(None, help=FILTER_STATE_HELP),
+    negate_filter_state: list[str] | None = typer.Option(None, help=NEGATE_FILTER_STATE_HELP),
     employee_range: str | None = typer.Option(None, help="Company employee range, e.g. 50-200."),
     has_email: bool | None = typer.Option(
         None, "--has-email/--no-has-email", help="Only contacts with (or without) an email address."
     ),
+    email_validated: bool | None = typer.Option(
+        None, "--email-validated/--no-email-validated", help=EMAIL_VALIDATED_HELP
+    ),
+    has_phone: bool | None = typer.Option(None, "--has-phone/--no-has-phone", help=HAS_PHONE_HELP),
+    has_mobile: bool | None = typer.Option(None, "--has-mobile/--no-has-mobile", help=HAS_MOBILE_HELP),
+    has_linkedin: bool | None = typer.Option(None, "--has-linkedin/--no-has-linkedin", help=HAS_LINKEDIN_HELP),
+    min_connections: int | None = typer.Option(None, help=MIN_CONNECTIONS_HELP),
     jobstart_date: str | None = typer.Option(None, "--jobstart-date", help=JOBSTART_DATE_HELP),
+    inclusion_query_id: list[str] | None = typer.Option(None, help=INCLUSION_QUERY_ID_HELP),
+    exclusion_query_id: list[str] | None = typer.Option(None, help=EXCLUSION_QUERY_ID_HELP),
     max_records: int | None = typer.Option(None, help="Maximum number of contacts to return."),
+    max_companies: int | None = typer.Option(None, help=MAX_COMPANIES_HELP),
     offset: int | None = typer.Option(None, help="Number of records to skip for pagination."),
     results_by_company: int | None = typer.Option(
         None, "--results-by-company", help="Maximum contacts returned per company."
@@ -258,17 +383,33 @@ def discover_command(
         negate_department=negate_department,
         title=title,
         negate_title=negate_title,
+        name=name,
+        summary=summary,
+        negate_summary=negate_summary,
+        skills=skills,
         domain=domain,
         person_country=person_country,
         negate_person_country=negate_person_country,
+        person_state=person_state,
+        persona_id=persona_id,
         filter_industry=filter_industry,
         negate_filter_industry=negate_filter_industry,
         filter_country=filter_country,
         negate_filter_country=negate_filter_country,
+        filter_state=filter_state,
+        negate_filter_state=negate_filter_state,
         employee_range=employee_range,
         has_email=has_email,
+        email_validated=email_validated,
+        has_phone=has_phone,
+        has_mobile=has_mobile,
+        has_linkedin=has_linkedin,
+        min_connections=min_connections,
         jobstart_date=jobstart_date,
+        inclusion_query_id=inclusion_query_id,
+        exclusion_query_id=exclusion_query_id,
         max_records=max_records,
+        max_companies=max_companies,
         offset=offset,
         results_by_company=results_by_company,
         include_search_contacts=include_search_contacts,
@@ -283,6 +424,12 @@ def generate_command(
     ctx: typer.Context,
     icp_text: str = typer.Option(..., "--icp-text", help="ICP description used to generate contacts."),
     domain: list[str] = typer.Option(..., "--domain", help="Target company domain (repeatable)."),
+    full_domain: list[str] | None = typer.Option(
+        None, "--full-domain", help="Domain to send as full_domains to the generation job (repeatable)."
+    ),
+    partial_domain: list[str] | None = typer.Option(
+        None, "--partial-domain", help="Domain to send as partial_domains to the generation job (repeatable)."
+    ),
     context_mode: str | None = typer.Option(None, "--context-mode", help="Context mode for generation."),
     integration_id: str | None = typer.Option(None, "--integration-id", help="Integration ID to use for generation."),
     search_provider_id: str | None = typer.Option(
@@ -310,6 +457,8 @@ def generate_command(
             None,
             icp_text=icp_text,
             domains=domain,
+            full_domains=full_domain,
+            partial_domains=partial_domain,
             context_mode=context_mode,
             integration_id=integration_id,
             search_provider_id=search_provider_id,

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/src/discolike_cli/discover.py

@@ -15,6 +15,19 @@ LIST_VALUE_SEPARATOR = ","
 
 FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
 PARAM_HELP = "Extra API parameter as KEY=VALUE (comma-separates into a list); see docs.discolike.com"
+SUBDOMAIN_HELP = "Limit results to this subdomain, up to 20, each at least 3 characters (repeatable)."
+NEGATE_SUBDOMAIN_HELP = "Exclude this subdomain, up to 20, each at least 3 characters (repeatable)."
+START_DATE_HELP = "Minimum company start date (YYYY-MM-DD) or range (YYYY-MM-DD,YYYY-MM-DD)."
+REDIRECT_HELP = "Include or exclude domains that redirect to another domain."
+SOCIAL_HELP = (
+    "Filter by social platform presence (repeatable): facebook, instagram, linkedin, pinterest, threads, tiktok, "
+    "twitter, x, yelp, youtube, googleplay, applestore, amazon, vk, bluesky, xing."
+)
+NEGATE_SOCIAL_HELP = "Exclude companies with this social profile (repeatable); same values as --social."
+LANGUAGE_HELP = "Filter by site language as an ISO 639-1 code, e.g. en, de, pb, zt (repeatable)."
+NEGATE_LANGUAGE_HELP = "Exclude this site language (repeatable); same values as --language."
+EXCLUDE_LEADGEN_HELP = "Exclude suspected lead generation sites (on by default)."
+COUNT_EXCLUDE_LEADGEN_HELP = "Exclude suspected lead generation sites (off by default for count)."
 
 
 def _parse_param(raw: str) -> tuple[str, str | list[str]]:
@@ -45,8 +58,15 @@ def discover_command(
     negate_country: list[str] | None = typer.Option(None, help="Negate the --country filter (repeatable)."),
     state: list[str] | None = typer.Option(None, help="State or region filter (repeatable)."),
     negate_state: list[str] | None = typer.Option(None, help="Negate the --state filter (repeatable)."),
+    subdomain: list[str] | None = typer.Option(None, help=SUBDOMAIN_HELP),
+    negate_subdomain: list[str] | None = typer.Option(None, help=NEGATE_SUBDOMAIN_HELP),
+    language: list[str] | None = typer.Option(None, help=LANGUAGE_HELP),
+    negate_language: list[str] | None = typer.Option(None, help=NEGATE_LANGUAGE_HELP),
+    social: list[str] | None = typer.Option(None, help=SOCIAL_HELP),
+    negate_social: list[str] | None = typer.Option(None, help=NEGATE_SOCIAL_HELP),
     employee_range: str | None = typer.Option(None, help="Employee count range filter."),
     revenue_range: str | None = typer.Option(None, help="Revenue range filter."),
+    start_date: str | None = typer.Option(None, help=START_DATE_HELP),
     business_model: list[str] | None = typer.Option(None, help="Business model filter (repeatable)."),
     negate_business_model: list[str] | None = typer.Option(
         None, help="Negate the --business-model filter (repeatable)."
@@ -55,7 +75,38 @@ def discover_command(
     negate_tech_stack: list[str] | None = typer.Option(None, help="Negate the --tech-stack filter (repeatable)."),
     min_digital_footprint: int | None = typer.Option(None, help="Minimum digital footprint score."),
     max_digital_footprint: int | None = typer.Option(None, help="Maximum digital footprint score."),
+    min_similarity: int | None = typer.Option(None, help="Minimum similarity score to include (0-99)."),
+    variance: str | None = typer.Option(
+        None, help="Result diversity control: LOW, MID_LOW, MEDIUM, MID_HIGH, HIGH, UNRESTRICTED."
+    ),
+    consensus: int | None = typer.Option(
+        None, help="Number of top results for the consensus search vector (1-20); higher reduces specificity."
+    ),
+    redirect: bool | None = typer.Option(None, "--redirect/--no-redirect", help=REDIRECT_HELP),
+    exclude_leadgen: bool | None = typer.Option(
+        None, "--exclude-leadgen/--no-exclude-leadgen", help=EXCLUDE_LEADGEN_HELP
+    ),
+    retrieval: bool | None = typer.Option(
+        None, "--retrieval/--no-retrieval", help="Enable page data retrieval using the Extract API."
+    ),
+    enhanced: bool | None = typer.Option(
+        None, "--enhanced/--no-enhanced", help="Enable AI-powered result enhancement for improved relevance."
+    ),
+    include_search_domains: bool | None = typer.Option(
+        None,
+        "--include-search-domains/--no-include-search-domains",
+        help="Include the input domains in results (excluded by default).",
+    ),
+    auto_icp_text: bool | None = typer.Option(
+        None, "--auto-icp-text/--no-auto-icp-text", help="Auto-generate ICP text from the provided domain(s)."
+    ),
+    auto_phrase_match: bool | None = typer.Option(
+        None, "--auto-phrase-match/--no-auto-phrase-match", help="Auto-generate phrase matches from ICP text."
+    ),
     exclude_domain: list[str] | None = typer.Option(None, help="Domain to exclude from results (repeatable)."),
+    inclusion_query_id: list[str] | None = typer.Option(
+        None, help="Saved query ID whose domains are included (repeatable); requires the STARTER plan."
+    ),
     exclusion_query_id: list[str] | None = typer.Option(
         None, help="Saved query ID whose results are excluded (repeatable)."
     ),
@@ -81,15 +132,33 @@ def discover_command(
             negate_country=negate_country,
             state=state,
             negate_state=negate_state,
+            subdomain=subdomain,
+            negate_subdomain=negate_subdomain,
+            language=language,
+            negate_language=negate_language,
+            social=social,
+            negate_social=negate_social,
             employee_range=employee_range,
             revenue_range=revenue_range,
+            start_date=start_date,
             business_model=business_model,
             negate_business_model=negate_business_model,
             tech_stack=tech_stack,
             negate_tech_stack=negate_tech_stack,
             min_digital_footprint=min_digital_footprint,
             max_digital_footprint=max_digital_footprint,
+            min_similarity=min_similarity,
+            variance=variance,
+            consensus=consensus,
+            redirect=redirect,
+            exclude_leadgen=exclude_leadgen,
+            retrieval=retrieval,
+            enhanced=enhanced,
+            include_search_domains=include_search_domains,
+            auto_icp_text=auto_icp_text,
+            auto_phrase_match=auto_phrase_match,
             exclude_domain=exclude_domain,
+            inclusion_query_id=inclusion_query_id,
             exclusion_query_id=exclusion_query_id,
             max_records=max_records,
             offset=offset,
@@ -109,8 +178,15 @@ def count_command(
     negate_country: list[str] | None = typer.Option(None, help="Negate the --country filter (repeatable)."),
     state: list[str] | None = typer.Option(None, help="State or region filter (repeatable)."),
     negate_state: list[str] | None = typer.Option(None, help="Negate the --state filter (repeatable)."),
+    subdomain: list[str] | None = typer.Option(None, help=SUBDOMAIN_HELP),
+    negate_subdomain: list[str] | None = typer.Option(None, help=NEGATE_SUBDOMAIN_HELP),
+    language: list[str] | None = typer.Option(None, help=LANGUAGE_HELP),
+    negate_language: list[str] | None = typer.Option(None, help=NEGATE_LANGUAGE_HELP),
+    social: list[str] | None = typer.Option(None, help=SOCIAL_HELP),
+    negate_social: list[str] | None = typer.Option(None, help=NEGATE_SOCIAL_HELP),
     employee_range: str | None = typer.Option(None, help="Employee count range filter."),
     revenue_range: str | None = typer.Option(None, help="Revenue range filter."),
+    start_date: str | None = typer.Option(None, help=START_DATE_HELP),
     business_model: list[str] | None = typer.Option(None, help="Business model filter (repeatable)."),
     negate_business_model: list[str] | None = typer.Option(
         None, help="Negate the --business-model filter (repeatable)."
@@ -119,6 +195,10 @@ def count_command(
     negate_tech_stack: list[str] | None = typer.Option(None, help="Negate the --tech-stack filter (repeatable)."),
     min_digital_footprint: int | None = typer.Option(None, help="Minimum digital footprint score."),
     max_digital_footprint: int | None = typer.Option(None, help="Maximum digital footprint score."),
+    redirect: bool | None = typer.Option(None, "--redirect/--no-redirect", help=REDIRECT_HELP),
+    exclude_leadgen: bool | None = typer.Option(
+        None, "--exclude-leadgen/--no-exclude-leadgen", help=COUNT_EXCLUDE_LEADGEN_HELP
+    ),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
     param: list[str] | None = typer.Option(None, "--param", help=PARAM_HELP),
 ) -> None:
@@ -137,14 +217,23 @@ def count_command(
             negate_country=negate_country,
             state=state,
             negate_state=negate_state,
+            subdomain=subdomain,
+            negate_subdomain=negate_subdomain,
+            language=language,
+            negate_language=negate_language,
+            social=social,
+            negate_social=negate_social,
             employee_range=employee_range,
             revenue_range=revenue_range,
+            start_date=start_date,
             business_model=business_model,
             negate_business_model=negate_business_model,
             tech_stack=tech_stack,
             negate_tech_stack=negate_tech_stack,
             min_digital_footprint=min_digital_footprint,
             max_digital_footprint=max_digital_footprint,
+            redirect=redirect,
+            exclude_leadgen=exclude_leadgen,
         ),
     )
     emit(get_client(ctx).count(request), fmt=fmt)

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/src/discolike_cli/enrich.py

@@ -19,6 +19,7 @@ DEFAULT_WAIT_TIMEOUT_SECONDS = 900.0
 FORMAT_HELP = "Output format: json or table (table auto-selected on a TTY; falls back to JSON for non-tabular data)."
 WAIT_HELP = "Block until the job finishes, streaming progress to stderr."
 TIMEOUT_HELP = "Max seconds to wait with --wait."
+QUERY_ID_HELP = "Saved query ID whose domains are included alongside the file/--domain ones (repeatable)."
 
 
 @handle_errors
@@ -76,6 +77,7 @@ def append_command(
     file: pathlib.Path = typer.Argument(..., help="CSV of domains to enrich."),
     dataset: list[str] | None = typer.Option(None, "--dataset", help="Dataset to append (repeatable)."),
     domain_column: str | None = typer.Option(None, "--domain-column", help="Column in the CSV that holds domains."),
+    query_id: list[str] | None = typer.Option(None, "--query-id", help=QUERY_ID_HELP),
     csv: bool | None = typer.Option(
         None, "--csv/--no-csv", help="Request the enriched rows as CSV (written via --output)."
     ),
@@ -85,7 +87,9 @@ def append_command(
     """Enrich a CSV of domains with DiscoLike datasets."""
     from discolike_cli.main import get_client
 
-    request = build_request(AppendParams, _merge_params(None, dataset=dataset, domain_column=domain_column, csv=csv))
+    request = build_request(
+        AppendParams, _merge_params(None, dataset=dataset, domain_column=domain_column, query_id=query_id, csv=csv)
+    )
     result = get_client(ctx).append(request, file=file)
     if isinstance(result, bytes):
         if output is None:
@@ -102,6 +106,7 @@ def segment_command(
     domain: list[str] | None = typer.Option(None, "--domain", help="Domain to segment (repeatable)."),
     file: pathlib.Path | None = typer.Option(None, "--file", help="CSV of domains to segment (instead of --domain)."),
     domain_column: str | None = typer.Option(None, "--domain-column", help="Column in --file that holds domains."),
+    query_id: list[str] | None = typer.Option(None, "--query-id", help=QUERY_ID_HELP),
     max_segments: int | None = typer.Option(None, "--max-segments", help="Maximum number of segments to produce."),
     wait: bool = typer.Option(False, "--wait", help=WAIT_HELP),
     timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
@@ -116,11 +121,14 @@ def segment_command(
     client = get_client(ctx)
     if file is not None:
         request = build_request(
-            SegmentFileParams, _merge_params(None, domain_column=domain_column, max_segments=max_segments)
+            SegmentFileParams,
+            _merge_params(None, domain_column=domain_column, query_id=query_id, max_segments=max_segments),
         )
         job = client.segment_file(request, file=file)
     else:
         assert domain is not None
-        request = build_request(SegmentParams, _merge_params(None, domains=",".join(domain), max_segments=max_segments))
+        request = build_request(
+            SegmentParams, _merge_params(None, domains=",".join(domain), query_id=query_id, max_segments=max_segments)
+        )
         job = client.segment(request)
     run_job(job, wait=wait, timeout=timeout, fmt=fmt)

{discolike_cli-0.3.0 → discolike_cli-0.3.2}/src/discolike_cli/main.py

@@ -18,6 +18,7 @@ from discolike_cli import enrich
 from discolike_cli import match
 from discolike_cli import providers
 from discolike_cli import queries
+from discolike_cli import signup
 
 app = typer.Typer(
     name="discolike",
@@ -70,3 +71,4 @@ 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)
+app.command(name="signup")(signup.signup_command)