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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: discolike-cli
-Version: 0.3.1
+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.1
+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.1 → discolike_cli-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "discolike-cli"
-version = "0.3.1"
+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.1",
+  "discolike==0.3.2",
   "typer>=0.12",
   "rich>=13.0",
 ]

{discolike_cli-0.3.1 → 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.1 → 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.1 → 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.1 → 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.1 → discolike_cli-0.3.2}/src/discolike_cli/match.py

@@ -18,6 +18,7 @@ DEFAULT_NAME_COLUMN = "name"
 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."
+MIN_MATCH_CONFIDENCE_HELP = "Minimum match_confidence (inclusive, 50-100) a match must have to be returned."
 
 
 @handle_errors
@@ -29,6 +30,7 @@ def match_command(
     state: str | None = typer.Option(None, help="State or region to disambiguate the match."),
     country: str | None = typer.Option(None, help="Country to disambiguate the match."),
     zip_code: str | None = typer.Option(None, help="ZIP or postal code to disambiguate the match."),
+    min_match_confidence: int | None = typer.Option(None, help=MIN_MATCH_CONFIDENCE_HELP),
     strict: bool | None = typer.Option(None, "--strict/--no-strict", help="Toggle strict matching."),
     local_mode: bool | None = typer.Option(None, "--local-mode/--no-local-mode", help="Toggle local matching mode."),
     file: pathlib.Path | None = typer.Option(
@@ -37,6 +39,15 @@ def match_command(
     name_column: str = typer.Option(
         DEFAULT_NAME_COLUMN, "--name-column", help="Column in --file that holds company names."
     ),
+    phone_column: str | None = typer.Option(None, "--phone-column", help="Column in --file that holds phone numbers."),
+    city_column: str | None = typer.Option(None, "--city-column", help="Column in --file that holds cities."),
+    state_column: str | None = typer.Option(None, "--state-column", help="Column in --file that holds states."),
+    country_column: str | None = typer.Option(
+        None, "--country-column", help="Column in --file that holds country codes."
+    ),
+    zip_code_column: str | None = typer.Option(
+        None, "--zip-code-column", help="Column in --file that holds zip codes."
+    ),
     wait: bool = typer.Option(False, "--wait", help=WAIT_HELP),
     timeout: float = typer.Option(DEFAULT_WAIT_TIMEOUT_SECONDS, "--timeout", help=TIMEOUT_HELP),
     fmt: str | None = typer.Option(None, "--format", help=FORMAT_HELP),
@@ -59,6 +70,7 @@ def match_command(
                 state=state,
                 country=country,
                 zip_code=zip_code,
+                min_match_confidence=min_match_confidence,
                 strict=strict,
                 local_mode=local_mode,
             ),
@@ -68,6 +80,18 @@ def match_command(
 
     assert file is not None
     request = build_request(
-        MatchBulkParams, _merge_params(None, name_column=name_column, strict=strict, local_mode=local_mode)
+        MatchBulkParams,
+        _merge_params(
+            None,
+            name_column=name_column,
+            phone_column=phone_column,
+            city_column=city_column,
+            state_column=state_column,
+            country_column=country_column,
+            zip_code_column=zip_code_column,
+            min_match_confidence=min_match_confidence,
+            strict=strict,
+            local_mode=local_mode,
+        ),
     )
     run_job(client.match.bulk(request, file=file), wait=wait, timeout=timeout, fmt=fmt)

{discolike_cli-0.3.1 → discolike_cli-0.3.2}/tests/test_company.py

@@ -144,3 +144,27 @@ def test_extract_hits_extract_endpoint_with_url(install_build_client: Callable[[
     assert request.url.path == "/v1/extract"
     assert request.url.params.get("url") == "https://acme.com/about"
     assert json.loads(result.stdout) == {"text": "hello", "language": "en"}
+
+
+def test_extract_domain_option_replaces_url(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json={"text": "hello", "language": "en"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["extract", "--domain", "acme.com"])
+    assert result.exit_code == 0, result.output
+    params = captured["request"].url.params
+    assert params.get("domain") == "acme.com"
+    assert "url" not in params
+
+
+def test_extract_requires_exactly_one_of_url_or_domain(install_build_client: Callable[[Handler], None]) -> None:
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json={})
+
+    install_build_client(handler)
+    assert runner.invoke(app, ["extract"]).exit_code == 2
+    assert runner.invoke(app, ["extract", "https://acme.com", "--domain", "acme.com"]).exit_code == 2

{discolike_cli-0.3.1 → discolike_cli-0.3.2}/tests/test_contacts_cli.py

@@ -76,6 +76,15 @@ def test_contacts_search_sends_options_and_param_escape_hatch(install_build_clie
     ]
 
 
+def test_contacts_search_icp_text_is_removed(install_build_client: Callable[[Handler], None]) -> None:
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json=[])
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "search", "--icp-text", "X"])
+    assert result.exit_code == 2
+
+
 def test_contacts_search_forwards_negate_options(install_build_client: Callable[[Handler], None]) -> None:
     captured: dict[str, httpx2.QueryParams] = {}
 
@@ -113,15 +122,6 @@ def test_contacts_search_forwards_negate_options(install_build_client: Callable[
     assert params.get_list("negate_filter_country") == ["RU"]
 
 
-def test_contacts_search_icp_text_is_removed(install_build_client: Callable[[Handler], None]) -> None:
-    def handler(request: httpx2.Request) -> httpx2.Response:
-        return httpx2.Response(200, json=[])
-
-    install_build_client(handler)
-    result = runner.invoke(app, ["contacts", "search", "--icp-text", "X"])
-    assert result.exit_code == 2
-
-
 def test_contacts_search_unknown_param_passes_through(install_build_client: Callable[[Handler], None]) -> None:
     captured: dict[str, httpx2.QueryParams] = {}
 
@@ -346,3 +346,156 @@ def test_contacts_generate_without_wait_prints_task_hint(install_build_client: C
     payload = json.loads(result.stdout)
     assert payload["task_id"] == "dg-1"
     assert payload["task_family"] == "discogen"
+
+
+NEW_CONTACT_FILTER_ARGS = [
+    "--name",
+    "Jane",
+    "--summary",
+    "scaled a sales org",
+    "--negate-summary",
+    "intern",
+    "--skills",
+    "SQL",
+    "--person-state",
+    "CA",
+    "--persona-id",
+    "7",
+    "--filter-state",
+    "TX",
+    "--negate-filter-state",
+    "NY",
+    "--email-validated",
+    "--has-phone",
+    "--no-has-mobile",
+    "--has-linkedin",
+    "--min-connections",
+    "500",
+    "--inclusion-query-id",
+    "q1",
+    "--exclusion-query-id",
+    "q2",
+    "--max-companies",
+    "10",
+    "--results-by-company",
+    "2",
+    "--include-search-contacts",
+    "--consensus",
+    "3",
+]
+
+
+def _assert_new_contact_filters(params: httpx2.QueryParams) -> None:
+    assert params.get("name") == "Jane"
+    assert params.get("summary") == "scaled a sales org"
+    assert params.get("negate_summary") == "intern"
+    assert params.get_list("skills") == ["SQL"]
+    assert params.get_list("person_state") == ["CA"]
+    assert params.get_list("persona_id") == ["7"]
+    assert params.get_list("filter_state") == ["TX"]
+    assert params.get_list("negate_filter_state") == ["NY"]
+    assert params.get("email_validated") == "true"
+    assert params.get("has_phone") == "true"
+    assert params.get("has_mobile") == "false"
+    assert params.get("has_linkedin") == "true"
+    assert params.get("min_connections") == "500"
+    assert params.get_list("inclusion_query_id") == ["q1"]
+    assert params.get_list("exclusion_query_id") == ["q2"]
+    assert params.get("max_companies") == "10"
+    assert params.get("results_by_company") == "2"
+    assert params.get("include_search_contacts") == "true"
+    assert params.get("consensus") == "3"
+
+
+def test_contacts_search_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return httpx2.Response(200, json=[])
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "search", *NEW_CONTACT_FILTER_ARGS])
+    assert result.exit_code == 0, result.output
+    _assert_new_contact_filters(captured["params"])
+
+
+def test_contacts_count_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return httpx2.Response(200, json={"count": 1})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "count", *NEW_CONTACT_FILTER_ARGS, "--max-records", "20", "--offset", "5"])
+    assert result.exit_code == 0, result.output
+    params = captured["params"]
+    _assert_new_contact_filters(params)
+    assert params.get("max_records") == "20"
+    assert params.get("offset") == "5"
+
+
+def test_contacts_discover_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, object] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["body"] = json.loads(request.content)
+        return httpx2.Response(200, json={"results": {}, "total_contacts": 0})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["contacts", "discover", *NEW_CONTACT_FILTER_ARGS])
+    assert result.exit_code == 0, result.output
+    assert captured["body"] == {
+        "name": "Jane",
+        "summary": "scaled a sales org",
+        "negate_summary": "intern",
+        "skills": ["SQL"],
+        "person_state": ["CA"],
+        "persona_id": [7],
+        "filter_state": ["TX"],
+        "negate_filter_state": ["NY"],
+        "email_validated": True,
+        "has_phone": True,
+        "has_mobile": False,
+        "has_linkedin": True,
+        "min_connections": 500,
+        "inclusion_query_id": ["q1"],
+        "exclusion_query_id": ["q2"],
+        "max_companies": 10,
+        "results_by_company": 2,
+        "include_search_contacts": True,
+        "consensus": 3,
+    }
+
+
+def test_contacts_generate_forwards_full_and_partial_domains(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, object] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["body"] = json.loads(request.content)
+        return httpx2.Response(200, json={"task_id": "dg-9"})
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "contacts",
+            "generate",
+            "--icp-text",
+            "VPs of Marketing",
+            "--domain",
+            "acme.com",
+            "--full-domain",
+            "done.com",
+            "--partial-domain",
+            "half.com",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert captured["body"] == {
+        "icp_text": "VPs of Marketing",
+        "domains": ["acme.com"],
+        "full_domains": ["done.com"],
+        "partial_domains": ["half.com"],
+    }

{discolike_cli-0.3.1 → discolike_cli-0.3.2}/tests/test_discover.py

@@ -118,6 +118,120 @@ def test_discover_icp_text_option_removed(install_build_client: Callable[[Handle
     assert result.exit_code == 2
 
 
+def test_discover_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return _discover_ok(request)
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "discover",
+            "--subdomain",
+            "shop",
+            "--negate-subdomain",
+            "blog",
+            "--language",
+            "en",
+            "--negate-language",
+            "de",
+            "--social",
+            "linkedin",
+            "--negate-social",
+            "tiktok",
+            "--start-date",
+            "2020-01-01",
+            "--min-similarity",
+            "40",
+            "--variance",
+            "MEDIUM",
+            "--consensus",
+            "3",
+            "--redirect",
+            "--no-exclude-leadgen",
+            "--retrieval",
+            "--enhanced",
+            "--include-search-domains",
+            "--auto-icp-text",
+            "--auto-phrase-match",
+            "--inclusion-query-id",
+            "q1",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    params = captured["params"]
+    assert params.get_list("subdomain") == ["shop"]
+    assert params.get_list("negate_subdomain") == ["blog"]
+    assert params.get_list("language") == ["en"]
+    assert params.get_list("negate_language") == ["de"]
+    assert params.get_list("social") == ["linkedin"]
+    assert params.get_list("negate_social") == ["tiktok"]
+    assert params.get("start_date") == "2020-01-01"
+    assert params.get("min_similarity") == "40"
+    assert params.get("variance") == "MEDIUM"
+    assert params.get("consensus") == "3"
+    assert params.get("redirect") == "true"
+    assert params.get("exclude_leadgen") == "false"
+    assert params.get("retrieval") == "true"
+    assert params.get("enhanced") == "true"
+    assert params.get("include_search_domains") == "true"
+    assert params.get("auto_icp_text") == "true"
+    assert params.get("auto_phrase_match") == "true"
+    assert params.get_list("inclusion_query_id") == ["q1"]
+
+
+def test_discover_rejects_invalid_variance(install_build_client: Callable[[Handler], None]) -> None:
+    install_build_client(_discover_ok)
+    result = runner.invoke(app, ["discover", "--variance", "BOGUS"])
+    assert result.exit_code == 2
+
+
+def test_count_forwards_every_new_flag(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.QueryParams] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["params"] = request.url.params
+        return _count_ok(request)
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "count",
+            "--subdomain",
+            "shop",
+            "--negate-subdomain",
+            "blog",
+            "--language",
+            "en",
+            "--negate-language",
+            "de",
+            "--social",
+            "linkedin",
+            "--negate-social",
+            "tiktok",
+            "--start-date",
+            "2020-01-01,2021-01-01",
+            "--no-redirect",
+            "--exclude-leadgen",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    params = captured["params"]
+    assert params.get_list("subdomain") == ["shop"]
+    assert params.get_list("negate_subdomain") == ["blog"]
+    assert params.get_list("language") == ["en"]
+    assert params.get_list("negate_language") == ["de"]
+    assert params.get_list("social") == ["linkedin"]
+    assert params.get_list("negate_social") == ["tiktok"]
+    assert params.get("start_date") == "2020-01-01,2021-01-01"
+    assert params.get("redirect") == "false"
+    assert params.get("exclude_leadgen") == "true"
+
+
 def test_count_sends_shared_filter_subset(install_build_client: Callable[[Handler], None]) -> None:
     captured: dict[str, httpx2.QueryParams] = {}
 

{discolike_cli-0.3.1 → discolike_cli-0.3.2}/tests/test_enrich_cli.py

@@ -234,3 +234,40 @@ def test_segment_neither_domain_nor_file_exits_2(install_build_client: Callable[
     install_build_client(handler)
     result = runner.invoke(app, ["segment"])
     assert result.exit_code == 2
+
+
+def test_append_forwards_query_id(tmp_path, install_build_client: Callable[[Handler], None]) -> None:
+    domains_file = tmp_path / "domains.csv"
+    domains_file.write_text("domain\nacme.com\n")
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json=[{"domain": "acme.com"}])
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app, ["append", str(domains_file), "--dataset", "bizdata", "--query-id", "q1", "--query-id", "q2"]
+    )
+    assert result.exit_code == 0, result.output
+    assert captured["request"].url.params.get_list("query_id") == ["q1", "q2"]
+
+
+def test_segment_forwards_query_id_for_domains_and_file(
+    tmp_path, install_build_client: Callable[[Handler], None]
+) -> None:
+    domains_file = tmp_path / "domains.csv"
+    domains_file.write_text("domain\nacme.com\n")
+    captured: list[httpx2.Request] = []
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured.append(request)
+        return httpx2.Response(200, json={"task_id": "sg-1"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["segment", "--domain", "acme.com", "--query-id", "q1"])
+    assert result.exit_code == 0, result.output
+    result = runner.invoke(app, ["segment", "--file", str(domains_file), "--query-id", "q2"])
+    assert result.exit_code == 0, result.output
+    assert captured[0].url.params.get_list("query_id") == ["q1"]
+    assert captured[1].url.params.get_list("query_id") == ["q2"]

{discolike_cli-0.3.1 → discolike_cli-0.3.2}/tests/test_match_cli.py

@@ -217,3 +217,58 @@ def test_match_bulk_local_mode_sent_when_passed(tmp_path, install_build_client:
     result = runner.invoke(app, ["match", "--file", str(names_file), "--local-mode"])
     assert result.exit_code == 0, result.output
     assert captured["request"].url.params.get("local_mode") == "true"
+
+
+def test_match_single_forwards_min_match_confidence(install_build_client: Callable[[Handler], None]) -> None:
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json={"domain": "acme.com"})
+
+    install_build_client(handler)
+    result = runner.invoke(app, ["match", "Acme", "--min-match-confidence", "80"])
+    assert result.exit_code == 0, result.output
+    assert captured["request"].url.params.get("min_match_confidence") == "80"
+
+
+def test_match_bulk_forwards_column_flags_and_confidence(
+    tmp_path, install_build_client: Callable[[Handler], None]
+) -> None:
+    names_file = tmp_path / "names.csv"
+    names_file.write_text("name,phone,city,state,country,zip\nAcme,555,Austin,TX,US,78701\n")
+    captured: dict[str, httpx2.Request] = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        captured["request"] = request
+        return httpx2.Response(200, json={"task_id": "bm-6"})
+
+    install_build_client(handler)
+    result = runner.invoke(
+        app,
+        [
+            "match",
+            "--file",
+            str(names_file),
+            "--phone-column",
+            "phone",
+            "--city-column",
+            "city",
+            "--state-column",
+            "state",
+            "--country-column",
+            "country",
+            "--zip-code-column",
+            "zip",
+            "--min-match-confidence",
+            "75",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    params = captured["request"].url.params
+    assert params.get("phone_column") == "phone"
+    assert params.get("city_column") == "city"
+    assert params.get("state_column") == "state"
+    assert params.get("country_column") == "country"
+    assert params.get("zip_code_column") == "zip"
+    assert params.get("min_match_confidence") == "75"

discolike_cli-0.3.2/tests/test_sdk_parity.py

@@ -0,0 +1,99 @@
+"""Every SDK request field must be reachable as a first-class CLI flag.
+
+Reads the CLI source with ``ast`` rather than invoking typer, so a new field on
+a request model fails here until the matching command forwards it.
+"""
+
+from __future__ import annotations
+
+import ast
+import pathlib
+from collections.abc import Iterator
+
+import pytest
+
+import discolike.requests as requests_module
+
+CLI_SOURCE_DIR = pathlib.Path(__file__).resolve().parents[1] / "src" / "discolike_cli"
+REQUEST_BUILDER = "build_request"
+# icp_text was dropped from discover and contacts in 0.1.1 in favor of icp_prompt; see the *_icp_text_*_removed tests.
+DELIBERATELY_OMITTED: dict[str, frozenset[str]] = {
+    "DiscoverParams": frozenset({"icp_text"}),
+    "ContactsSearchParams": frozenset({"icp_text"}),
+    "ContactsCountParams": frozenset({"icp_text"}),
+    "ContactFilters": frozenset({"icp_text"}),
+}
+DICT_ONLY_FIELDS: dict[str, frozenset[str]] = {
+    "ContactGenerateRequest": frozenset({"initial_contact_counts"}),
+    "DiscoGenProcessRequest": frozenset({"previous_discogen_data"}),
+    "DiscoGenPersonaProcessRequest": frozenset({"previous_discogen_data"}),
+    "SaveResultsRequest": frozenset({"query_params"}),
+}
+
+
+def _keyword_names(call: ast.Call) -> set[str]:
+    return {keyword.arg for keyword in call.keywords if keyword.arg is not None}
+
+
+def _dict_keys(node: ast.Dict, assignments: dict[str, ast.Call]) -> set[str]:
+    keys: set[str] = set()
+    for key, value in zip(node.keys, node.values, strict=True):
+        if key is None:
+            keys |= _forwarded_fields(argument=value, assignments=assignments)
+        elif isinstance(key, ast.Constant) and isinstance(key.value, str):
+            keys.add(key.value)
+    return keys
+
+
+def _forwarded_fields(argument: ast.expr, assignments: dict[str, ast.Call]) -> set[str]:
+    if isinstance(argument, ast.Name) and argument.id in assignments:
+        argument = assignments[argument.id]
+    if isinstance(argument, ast.Call):
+        return _keyword_names(argument)
+    if isinstance(argument, ast.Dict):
+        return _dict_keys(node=argument, assignments=assignments)
+    return set()
+
+
+def _build_request_sites() -> Iterator[tuple[str, str, set[str]]]:
+    for source_file in sorted(CLI_SOURCE_DIR.glob("*.py")):
+        tree = ast.parse(source_file.read_text())
+        for function in (node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)):
+            assignments = {
+                node.targets[0].id: node.value
+                for node in ast.walk(function)
+                if isinstance(node, ast.Assign)
+                and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)
+                and isinstance(node.value, ast.Call)
+            }
+            for call in (node for node in ast.walk(function) if isinstance(node, ast.Call)):
+                callee = call.func.id if isinstance(call.func, ast.Name) else getattr(call.func, "attr", "")
+                if callee != REQUEST_BUILDER or not call.args or not isinstance(call.args[0], ast.Name):
+                    continue
+                forwarded: set[str] = set()
+                for argument in call.args[1:]:
+                    forwarded |= _forwarded_fields(argument=argument, assignments=assignments)
+                yield f"{source_file.stem}.{function.name}", call.args[0].id, forwarded
+
+
+SITES = list(_build_request_sites())
+
+
+@pytest.mark.parametrize(("site", "model_name", "forwarded"), SITES, ids=[f"{s}->{m}" for s, m, _ in SITES])
+def test_cli_forwards_every_sdk_field(site: str, model_name: str, forwarded: set[str]) -> None:
+    model = getattr(requests_module, model_name)
+    excluded = DICT_ONLY_FIELDS.get(model_name, frozenset()) | DELIBERATELY_OMITTED.get(model_name, frozenset())
+    expected = set(model.model_fields) - excluded
+    missing = sorted(expected - forwarded)
+    assert not missing, f"{site} does not forward {model_name} fields: {', '.join(missing)}"
+
+
+def test_every_request_model_has_a_cli_command() -> None:
+    used = {model_name for _, model_name, _ in SITES}
+    declared = {
+        name
+        for name in dir(requests_module)
+        if name.endswith(("Params", "Request")) and hasattr(getattr(requests_module, name), "model_fields")
+    }
+    assert not sorted(declared - used), f"request models with no CLI command: {sorted(declared - used)}"