@hasna/connectors 1.0.4 → 1.0.6

package/connectors/connect-patentsview/README.md

@@ -0,0 +1,334 @@
+# connect-patentsview
+
+A TypeScript connector for the USPTO PatentsView API. Search and analyze US patent data including patents, inventors, assignees, CPC classifications, and locations.
+
+## Features
+
+- Search patents by title, abstract, assignee, inventor, CPC classification
+- Search inventors and assignees
+- Browse CPC (Cooperative Patent Classification) hierarchy
+- Location-based patent analytics
+- Multi-profile configuration support
+- Pretty and JSON output formats
+- TypeScript with full type definitions
+
+## Prerequisites
+
+**API Key Required:** The PatentsView API requires an API key for authentication.
+
+Get your free API key at: https://patentsview-support.atlassian.net/servicedesk/customer/portal/1/group/1/create/18
+
+## Installation
+
+```bash
+# Install globally
+bun install -g @hasna/connect-patentsview
+
+# Or use directly
+bunx @hasna/connect-patentsview
+```
+
+## Quick Start
+
+```bash
+# Configure your API key
+connect-patentsview config set-key YOUR_API_KEY
+
+# Search patents by title
+connect-patentsview patents search --title "artificial intelligence"
+
+# Get a specific patent
+connect-patentsview patents get 10000000
+
+# Search top assignees
+connect-patentsview assignees top --limit 25
+
+# Search inventors by name
+connect-patentsview inventors search --name "Smith"
+
+# Browse CPC classifications
+connect-patentsview cpc sections
+connect-patentsview cpc search --section G
+
+# Get top patent locations
+connect-patentsview locations top --us
+```
+
+## CLI Commands
+
+### Patents
+
+```bash
+# Search patents
+connect-patentsview patents search [options]
+  --title <text>      Search by title
+  --abstract <text>   Search by abstract
+  --assignee <name>   Search by assignee organization
+  --inventor <name>   Search by inventor last name
+  --cpc <code>        Search by CPC classification
+  --year <year>       Filter by year
+  --from <date>       Start date (YYYY-MM-DD)
+  --to <date>         End date (YYYY-MM-DD)
+  --limit <n>         Number of results (default: 25)
+  --page <n>          Page number (default: 1)
+
+# Get single patent
+connect-patentsview patents get <patentId>
+
+# Get recent patents
+connect-patentsview patents recent --limit 50
+
+# Get most cited patents
+connect-patentsview patents cited --limit 25
+```
+
+### Assignees
+
+```bash
+# Search assignees
+connect-patentsview assignees search [options]
+  --org <name>        Search by organization name
+  --name <lastname>   Search by individual last name
+  --country <code>    Filter by country
+  --state <code>      Filter by state (US only)
+
+# Get single assignee
+connect-patentsview assignees get <assigneeId>
+
+# Get top assignees by patent count
+connect-patentsview assignees top --limit 25
+```
+
+### Inventors
+
+```bash
+# Search inventors
+connect-patentsview inventors search [options]
+  --name <lastname>   Search by last name
+  --first <firstname> Filter by first name
+  --country <code>    Filter by country
+  --state <code>      Filter by state (US only)
+
+# Get single inventor
+connect-patentsview inventors get <inventorId>
+
+# Get top inventors
+connect-patentsview inventors top --limit 25
+
+# Get prolific inventors (with many patents)
+connect-patentsview inventors prolific --min 100
+```
+
+### CPC Classifications
+
+```bash
+# Search CPC subgroups
+connect-patentsview cpc search [options]
+  --title <text>      Search by title
+  --section <id>      Filter by section (A-H, Y)
+  --class <id>        Filter by class (e.g., G06)
+  --subclass <id>     Filter by subclass (e.g., G06F)
+  --group <id>        Filter by group (e.g., G06F3/00)
+  --prefix <id>       Search by ID prefix
+
+# Get single CPC subgroup
+connect-patentsview cpc get <cpcId>
+
+# List CPC sections
+connect-patentsview cpc sections
+
+# Get top CPC subgroups by patent count
+connect-patentsview cpc top --limit 25
+```
+
+### Locations
+
+```bash
+# Search locations
+connect-patentsview locations search [options]
+  --country <code>    Filter by country
+  --state <code>      Filter by state (US only)
+  --city <name>       Search by city name
+
+# Get top locations
+connect-patentsview locations top [options]
+  --us                US locations only
+  --state <code>      Top cities in a specific US state
+```
+
+### Configuration
+
+```bash
+# Set API key
+connect-patentsview config set-key YOUR_API_KEY
+
+# Show configuration
+connect-patentsview config show
+
+# Manage profiles
+connect-patentsview profile list
+connect-patentsview profile create <name> [--api-key KEY] [--use]
+connect-patentsview profile use <name>
+connect-patentsview profile show [name]
+connect-patentsview profile delete <name>
+```
+
+## Programmatic Usage
+
+```typescript
+import { PatentsView } from '@hasna/connect-patentsview';
+
+// Create client with API key
+const pv = new PatentsView({ apiKey: 'your-api-key' });
+
+// Or from environment variable (PATENTSVIEW_API_KEY)
+const pv = PatentsView.fromEnv();
+
+// Search patents
+const results = await pv.patents.searchByTitle('machine learning', {
+  per_page: 25,
+  sort: [{ patent_date: 'desc' }],
+});
+
+console.log(`Found ${results.total_hits} patents`);
+results.patents.forEach(p => {
+  console.log(`${p.patent_id}: ${p.patent_title}`);
+});
+
+// Get a specific patent
+const patent = await pv.patents.get('10000000');
+
+// Search assignees
+const assignees = await pv.assignees.searchByOrganization('Microsoft');
+
+// Get prolific inventors
+const inventors = await pv.inventors.getProlific(200);
+
+// Search CPC classifications
+const cpc = await pv.cpc.searchBySection('H'); // Electricity
+
+// Custom query with all options
+const customSearch = await pv.patents.search(
+  // Query filters
+  {
+    _and: [
+      { patent_year: { _gte: 2020 } },
+      { assignees: { assignee_organization: { _contains: 'IBM' } } },
+    ],
+  },
+  // Fields to return
+  ['patent_id', 'patent_title', 'patent_date', 'patent_num_cited_by_us_patents'],
+  // Options
+  {
+    per_page: 100,
+    page: 1,
+    sort: [{ patent_num_cited_by_us_patents: 'desc' }],
+  }
+);
+```
+
+## API Reference
+
+### Query Operators
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `_eq` | Equals | `{ "patent_year": { "_eq": 2024 } }` |
+| `_neq` | Not equals | `{ "patent_type": { "_neq": "design" } }` |
+| `_gt` | Greater than | `{ "patent_num_claims": { "_gt": 10 } }` |
+| `_gte` | Greater than or equal | `{ "patent_year": { "_gte": 2020 } }` |
+| `_lt` | Less than | `{ "patent_year": { "_lt": 2000 } }` |
+| `_lte` | Less than or equal | `{ "patent_num_claims": { "_lte": 5 } }` |
+| `_begins` | Starts with | `{ "inventor_name_last": { "_begins": "Sm" } }` |
+| `_contains` | Contains | `{ "assignee_organization": { "_contains": "Google" } }` |
+| `_text_any` | Full-text (any word) | `{ "patent_title": { "_text_any": "AI machine learning" } }` |
+| `_text_all` | Full-text (all words) | `{ "patent_abstract": { "_text_all": "neural network" } }` |
+| `_text_phrase` | Full-text (exact phrase) | `{ "patent_title": { "_text_phrase": "deep learning" } }` |
+
+### Logical Operators
+
+```typescript
+// AND - all conditions must match
+{
+  "_and": [
+    { "patent_year": { "_gte": 2020 } },
+    { "patent_type": { "_eq": "utility" } }
+  ]
+}
+
+// OR - any condition must match
+{
+  "_or": [
+    { "assignee_country": { "_eq": "US" } },
+    { "assignee_country": { "_eq": "JP" } }
+  ]
+}
+
+// NOT - negate a condition
+{
+  "_not": { "patent_type": { "_eq": "design" } }
+}
+```
+
+### CPC Sections
+
+| Section | Description |
+|---------|-------------|
+| A | Human Necessities |
+| B | Performing Operations; Transporting |
+| C | Chemistry; Metallurgy |
+| D | Textiles; Paper |
+| E | Fixed Constructions |
+| F | Mechanical Engineering; Lighting; Heating; Weapons; Blasting |
+| G | Physics |
+| H | Electricity |
+| Y | General Tagging of New Technological Developments |
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `PATENTSVIEW_API_KEY` | API key for authentication | Required |
+| `PATENTSVIEW_BASE_URL` | Override API base URL | `https://search.patentsview.org/api/v1` |
+
+## Data Storage
+
+Configuration is stored in `~/.connect/connect-patentsview/`:
+
+```
+~/.connect/connect-patentsview/
+├── current_profile   # Active profile name
+└── profiles/
+    ├── default.json  # Default profile
+    └── custom.json   # Custom profiles
+```
+
+## Rate Limits
+
+The PatentsView API has a rate limit of **45 requests per minute** per API key.
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run CLI in development
+bun run dev
+
+# Build
+bun run build
+
+# Type check
+bun run typecheck
+```
+
+## API Documentation
+
+- [PatentsView API Documentation](https://search.patentsview.org/docs)
+- [PatentsView Data Dictionary](https://patentsview.org/download/data-download-dictionary)
+- [Get API Key](https://patentsview-support.atlassian.net/servicedesk/customer/portal/1/group/1/create/18)
+
+## License
+
+MIT

package/connectors/connect-patentsview/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@hasna/connect-patentsview",
+  "version": "0.0.1",
+  "description": "PatentsView USPTO patent analytics API connector - Search patents, inventors, assignees, and CPC classifications",
+  "type": "module",
+  "bin": {
+    "connect-patentsview": "./bin/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
+    "dev": "bun run ./src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "patentsview",
+    "uspto",
+    "patents",
+    "patent-search",
+    "inventors",
+    "assignees",
+    "cpc",
+    "api",
+    "connector",
+    "cli",
+    "typescript",
+    "bun"
+  ],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/connect-patentsview.git"
+  }
+}

package/connectors/connect-patentsview/src/api/assignees.ts

@@ -0,0 +1,182 @@
+import type { PatentsViewClient } from './client';
+import type {
+  Assignee,
+  AssigneeSearchResponse,
+  AssigneeGetResponse,
+  QueryObject,
+  QueryOptions,
+  SearchRequest,
+} from '../types';
+import { DEFAULT_ASSIGNEE_FIELDS } from '../types';
+
+/**
+ * Assignees API - Search and retrieve assignee data
+ */
+export class AssigneesApi {
+  constructor(private readonly client: PatentsViewClient) {}
+
+  /**
+   * Search assignees with filters
+   * @param query - Query object with filters
+   * @param fields - Fields to return (defaults to common fields)
+   * @param options - Pagination and sorting options
+   */
+  async search(
+    query?: QueryObject,
+    fields?: string[],
+    options?: QueryOptions
+  ): Promise<AssigneeSearchResponse> {
+    const body: SearchRequest = {};
+
+    if (query) {
+      body.q = query;
+    }
+
+    body.f = fields || DEFAULT_ASSIGNEE_FIELDS;
+
+    if (options) {
+      body.o = options;
+    }
+
+    return this.client.post<AssigneeSearchResponse>('/assignee/', body);
+  }
+
+  /**
+   * Get a single assignee by ID
+   * @param assigneeId - The assignee ID
+   * @param fields - Fields to return
+   */
+  async get(assigneeId: string, fields?: string[]): Promise<Assignee | null> {
+    const response = await this.client.get<AssigneeGetResponse>(
+      `/assignee/${assigneeId}/`,
+      fields ? { f: fields.join(',') } : undefined
+    );
+    return response.assignees?.[0] || null;
+  }
+
+  /**
+   * Search assignees by organization name
+   * @param organization - Organization name
+   * @param options - Pagination options
+   */
+  async searchByOrganization(organization: string, options?: QueryOptions): Promise<AssigneeSearchResponse> {
+    return this.search(
+      { assignee_organization: { _contains: organization } },
+      undefined,
+      options
+    );
+  }
+
+  /**
+   * Search assignees by individual name
+   * @param lastName - Last name
+   * @param firstName - First name (optional)
+   * @param options - Pagination options
+   */
+  async searchByName(
+    lastName: string,
+    firstName?: string,
+    options?: QueryOptions
+  ): Promise<AssigneeSearchResponse> {
+    const query: QueryObject = {
+      assignee_individual_name_last: { _eq: lastName },
+    };
+
+    if (firstName) {
+      query.assignee_individual_name_first = { _eq: firstName };
+    }
+
+    return this.search(query, undefined, options);
+  }
+
+  /**
+   * Search assignees by location
+   * @param country - Country code
+   * @param state - State (optional)
+   * @param city - City (optional)
+   * @param options - Pagination options
+   */
+  async searchByLocation(
+    country: string,
+    state?: string,
+    city?: string,
+    options?: QueryOptions
+  ): Promise<AssigneeSearchResponse> {
+    const conditions: QueryObject[] = [
+      { assignee_country: { _eq: country } },
+    ];
+
+    if (state) {
+      conditions.push({ assignee_state: { _eq: state } });
+    }
+
+    if (city) {
+      conditions.push({ assignee_city: { _eq: city } });
+    }
+
+    return this.search(
+      conditions.length > 1 ? { _and: conditions } : conditions[0],
+      undefined,
+      options
+    );
+  }
+
+  /**
+   * Search assignees by type
+   * @param type - Assignee type (e.g., "2" for US Company)
+   * @param options - Pagination options
+   */
+  async searchByType(type: string, options?: QueryOptions): Promise<AssigneeSearchResponse> {
+    return this.search(
+      { assignee_type: { _eq: type } },
+      [...DEFAULT_ASSIGNEE_FIELDS, 'assignee_type'],
+      options
+    );
+  }
+
+  /**
+   * Get top assignees by patent count
+   * @param limit - Number of assignees to return
+   */
+  async getTopByPatentCount(limit = 25): Promise<AssigneeSearchResponse> {
+    return this.search(
+      undefined,
+      [...DEFAULT_ASSIGNEE_FIELDS, 'assignee_num_patents'],
+      {
+        per_page: limit,
+        sort: [{ assignee_num_patents: 'desc' }],
+      }
+    );
+  }
+
+  /**
+   * Get top assignees by inventor count
+   * @param limit - Number of assignees to return
+   */
+  async getTopByInventorCount(limit = 25): Promise<AssigneeSearchResponse> {
+    return this.search(
+      undefined,
+      [...DEFAULT_ASSIGNEE_FIELDS, 'assignee_num_inventors'],
+      {
+        per_page: limit,
+        sort: [{ assignee_num_inventors: 'desc' }],
+      }
+    );
+  }
+
+  /**
+   * Search for US companies (assignee_type = 2)
+   * @param options - Pagination options
+   */
+  async searchUSCompanies(options?: QueryOptions): Promise<AssigneeSearchResponse> {
+    return this.searchByType('2', options);
+  }
+
+  /**
+   * Search for foreign companies (assignee_type = 3)
+   * @param options - Pagination options
+   */
+  async searchForeignCompanies(options?: QueryOptions): Promise<AssigneeSearchResponse> {
+    return this.searchByType('3', options);
+  }
+}

package/connectors/connect-patentsview/src/api/client.ts

@@ -0,0 +1,139 @@
+import type { PatentsViewConfig } from '../types';
+import { PatentsViewApiError } from '../types';
+
+const DEFAULT_BASE_URL = 'https://search.patentsview.org/api/v1';
+
+export interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: Record<string, unknown> | unknown[] | string;
+  headers?: Record<string, string>;
+}
+
+export class PatentsViewClient {
+  private readonly apiKey?: string;
+  private readonly baseUrl: string;
+
+  constructor(config: PatentsViewConfig = {}) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+  }
+
+  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+    // Ensure path starts with /
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const url = new URL(`${this.baseUrl}${normalizedPath}`);
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  /**
+   * Make a request to the PatentsView API
+   * Requires API key authentication via X-Api-Key header
+   */
+  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+    const { method = 'GET', params, body, headers = {} } = options;
+
+    const url = this.buildUrl(path, params);
+
+    const requestHeaders: Record<string, string> = {
+      'Accept': 'application/json',
+      ...headers,
+    };
+
+    // Add API key if provided
+    if (this.apiKey) {
+      requestHeaders['X-Api-Key'] = this.apiKey;
+    }
+
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      requestHeaders['Content-Type'] = 'application/json';
+    }
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers: requestHeaders,
+    };
+
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    const response = await fetch(url, fetchOptions);
+
+    // Handle 204 No Content
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    // Parse response
+    let data: unknown;
+    const contentType = response.headers.get('content-type') || '';
+
+    if (contentType.includes('application/json')) {
+      const text = await response.text();
+      if (text) {
+        try {
+          data = JSON.parse(text);
+        } catch {
+          data = text;
+        }
+      }
+    } else {
+      data = await response.text();
+    }
+
+    // Handle errors
+    if (!response.ok) {
+      const errorMessage = typeof data === 'object' && data !== null
+        ? JSON.stringify(data)
+        : String(data || response.statusText);
+      throw new PatentsViewApiError(errorMessage, response.status);
+    }
+
+    return data as T;
+  }
+
+  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'GET', params });
+  }
+
+  async post<T>(path: string, body?: Record<string, unknown> | unknown[] | string | object, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
+  }
+
+  /**
+   * Get the base URL (for display/debugging)
+   */
+  getBaseUrl(): string {
+    return this.baseUrl;
+  }
+
+  /**
+   * Get a preview of the API key (for display/debugging)
+   */
+  getApiKeyPreview(): string {
+    if (!this.apiKey) {
+      return 'not set';
+    }
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return '***';
+  }
+
+  /**
+   * Check if API key is configured
+   */
+  hasApiKey(): boolean {
+    return !!this.apiKey;
+  }
+}