@hasna/connectors 1.3.43 → 1.3.44

package/connectors/you-com/.env.example

@@ -0,0 +1,4 @@
+# You.com API Key
+# Get your API key from: https://you.com/platform/api-keys
+
+YDC_API_KEY=your-api-key-here

package/connectors/you-com/CLAUDE.md

@@ -0,0 +1,108 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with code in this repository.
+
+## Project Overview
+
+connect-you-com is a TypeScript CLI and library for the You.com Web Search and Research APIs. It provides LLM-ready web search via `ydc-index.io` and citation-backed deep research via `api.you.com`.
+
+## Build & Run Commands
+
+```bash
+bun install
+bun run dev
+bun run build
+bun run typecheck
+bun test
+
+# Example commands
+bun run dev search "latest AI developments" --count 5
+bun run dev search-post "cloud providers" --include-domains aws.amazon.com,cloud.google.com
+bun run dev research "microservices vs monolith tradeoffs" --effort standard
+```
+
+## Code Style
+
+- TypeScript with strict mode
+- ESM modules (type: module)
+- Use async/await for all async operations
+- Minimal dependencies: commander, chalk only
+- Type annotations required everywhere
+
+## Project Structure
+
+```
+src/
+├── api/
+│   ├── client.ts     # HTTP client with X-API-Key auth
+│   ├── search.ts     # GET/POST /v1/search
+│   ├── research.ts   # POST /v1/research
+│   └── index.ts      # Main YouCom class
+├── cli/
+│   └── index.ts      # CLI commands
+├── types/
+│   └── index.ts      # API types
+├── utils/
+│   ├── config.ts     # Multi-profile configuration
+│   └── output.ts     # CLI output formatting
+└── index.ts          # Library exports
+```
+
+## API Endpoints
+
+| API | Base URL | Endpoint |
+|-----|----------|----------|
+| Search | `https://ydc-index.io` | `GET/POST /v1/search` |
+| Research | `https://api.you.com` | `POST /v1/research` |
+
+Docs: https://you.com/docs
+
+## Authentication
+
+API Key authentication via `X-API-Key` header. Credentials can be set via:
+- Environment variable `YDC_API_KEY`
+- Profile configuration: `connect-you-com config set-key <key>`
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `YDC_API_KEY` | You.com API key |
+| `YDC_SEARCH_BASE_URL` | Optional search API base URL override |
+| `YDC_RESEARCH_BASE_URL` | Optional research API base URL override |
+
+## Data Storage
+
+```
+~/.hasna/connectors/connect-you-com/
+├── current_profile   # Active profile name
+└── profiles/
+    ├── default.json  # Default profile
+    └── {name}.json   # Named profiles
+```
+
+Profile JSON:
+```json
+{
+  "apiKey": "your-key-here"
+}
+```
+
+## CLI Commands
+
+```bash
+connect-you-com search <query> [--count N] [--freshness week] [--livecrawl all]
+connect-you-com search-post <query> [--include-domains a.com,b.com] [--exclude-domains spam.com]
+connect-you-com research <input> [--effort standard|lite|deep|exhaustive]
+
+connect-you-com config set-key <key>
+connect-you-com config show
+connect-you-com config clear
+
+connect-you-com profile list|use|create|delete|show
+```
+
+## Dependencies
+
+- commander: CLI framework
+- chalk: Terminal styling

package/connectors/you-com/README.md

@@ -0,0 +1,67 @@
+# @hasna/connect-you-com
+
+You.com Web Search and Research API connector for the open-connectors monorepo.
+
+## Features
+
+- **Web Search** — LLM-ready results from `GET/POST https://ydc-index.io/v1/search`
+- **Deep Research** — Citation-backed answers from `POST https://api.you.com/v1/research`
+- **CLI** — `search`, `search-post`, `research`, config, and profile commands
+- **Library** — TypeScript client with typed request/response interfaces
+
+## Setup
+
+```bash
+cd connectors/you-com
+bun install
+export YDC_API_KEY="your-api-key"  # https://you.com/platform/api-keys
+```
+
+Or persist the key in a profile:
+
+```bash
+bun run dev config set-key your-api-key
+```
+
+## Usage
+
+```bash
+# Simple web search
+connect-you-com search "global birth rate trends" --count 5
+
+# Search with domain allowlist (POST)
+connect-you-com search-post "cloud providers" \
+  --include-domains aws.amazon.com,cloud.google.com \
+  --count 10
+
+# Deep research with citations
+connect-you-com research "microservices vs monolith tradeoffs for high traffic" \
+  --effort standard
+
+# JSON output
+connect-you-com search "AI news" -f json
+```
+
+## Library
+
+```typescript
+import { YouCom } from '@hasna/connect-you-com';
+
+const client = new YouCom({ apiKey: process.env.YDC_API_KEY! });
+
+const search = await client.search.get({ query: 'latest AI news', count: 5 });
+const research = await client.research.create({
+  input: 'Compare top three cloud providers',
+  research_effort: 'standard',
+});
+```
+
+## Documentation
+
+- You.com API docs: https://you.com/docs
+- Search reference: https://you.com/docs/api-reference/search/v1-search
+- Research reference: https://you.com/docs/api-reference/research/v1-research
+
+## License
+
+Apache-2.0

package/connectors/you-com/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@hasna/connect-you-com",
+  "version": "0.0.1",
+  "description": "You.com Web Search and Research API connector CLI",
+  "type": "module",
+  "bin": {
+    "connect-you-com": "./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",
+    "test": "bun test",
+    "prepublishOnly": "bun run build",
+    "release": "bun run ./scripts/publish.ts",
+    "release:patch": "bun run ./scripts/publish.ts patch",
+    "release:minor": "bun run ./scripts/publish.ts minor",
+    "release:major": "bun run ./scripts/publish.ts major",
+    "release:dry": "bun run ./scripts/publish.ts --dry-run"
+  },
+  "keywords": [
+    "you-com",
+    "you.com",
+    "search",
+    "web-search",
+    "research",
+    "ai",
+    "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/open-connectors.git"
+  }
+}

package/connectors/you-com/src/api/client.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { YouCom } from './index';
+
+const realFetch = globalThis.fetch;
+
+interface RecordedRequest {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body?: string;
+}
+
+function installFetch(
+  handler: (url: string, init: RequestInit | undefined, recorded: RecordedRequest[]) => unknown,
+) {
+  const recorded: RecordedRequest[] = [];
+  globalThis.fetch = (async (input: string | URL | Request, init?: RequestInit) => {
+    const url = typeof input === 'string' ? input : input.toString();
+    const headers: Record<string, string> = {};
+    if (init?.headers) {
+      const raw = init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers;
+      Object.assign(headers, raw);
+    }
+    recorded.push({
+      url,
+      method: init?.method ?? 'GET',
+      headers,
+      body: typeof init?.body === 'string' ? init.body : undefined,
+    });
+    const json = handler(url, init, recorded);
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: new Headers({ 'content-type': 'application/json' }),
+      async text() {
+        return JSON.stringify(json ?? {});
+      },
+    } as Response;
+  }) as typeof fetch;
+  return recorded;
+}
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+describe('YouComClient', () => {
+  test('search.get sends X-API-Key to ydc-index.io/v1/search', async () => {
+    const recorded = installFetch(() => ({ results: { web: [] } }));
+    const client = new YouCom({ apiKey: 'test-key-123' });
+    await client.search.get({ query: 'ai news', count: 5 });
+
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0].url).toContain('https://ydc-index.io/v1/search');
+    expect(recorded[0].url).toContain('query=ai+news');
+    expect(recorded[0].url).toContain('count=5');
+    expect(recorded[0].method).toBe('GET');
+    expect(recorded[0].headers['X-API-Key']).toBe('test-key-123');
+  });
+
+  test('search.post sends JSON body with domain filters', async () => {
+    const recorded = installFetch(() => ({ results: { web: [] } }));
+    const client = new YouCom({ apiKey: 'test-key-123' });
+    await client.search.post({
+      query: 'cloud providers',
+      include_domains: ['aws.amazon.com', 'cloud.google.com'],
+    });
+
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0].url).toBe('https://ydc-index.io/v1/search');
+    expect(recorded[0].method).toBe('POST');
+    expect(recorded[0].headers['X-API-Key']).toBe('test-key-123');
+    expect(recorded[0].headers['Content-Type']).toBe('application/json');
+    const body = JSON.parse(recorded[0].body!);
+    expect(body.query).toBe('cloud providers');
+    expect(body.include_domains).toEqual(['aws.amazon.com', 'cloud.google.com']);
+  });
+
+  test('research.create posts to api.you.com/v1/research', async () => {
+    const recorded = installFetch(() => ({ output: { content: 'answer' } }));
+    const client = new YouCom({ apiKey: 'test-key-123' });
+    await client.research.create({
+      input: 'What are microservices tradeoffs?',
+      research_effort: 'standard',
+    });
+
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0].url).toBe('https://api.you.com/v1/research');
+    expect(recorded[0].method).toBe('POST');
+    expect(recorded[0].headers['X-API-Key']).toBe('test-key-123');
+    const body = JSON.parse(recorded[0].body!);
+    expect(body.input).toBe('What are microservices tradeoffs?');
+    expect(body.research_effort).toBe('standard');
+  });
+
+  test('requires API key', () => {
+    expect(() => new YouCom({ apiKey: '' })).toThrow('API key is required');
+  });
+});

package/connectors/you-com/src/api/client.ts

@@ -0,0 +1,133 @@
+import type { YouComConfig } from '../types';
+import { YouComApiError } from '../types';
+
+export const DEFAULT_SEARCH_BASE_URL = 'https://ydc-index.io';
+export const DEFAULT_RESEARCH_BASE_URL = 'https://api.you.com';
+
+export interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: Record<string, unknown> | unknown[] | string | object;
+  headers?: Record<string, string>;
+  baseUrl?: string;
+}
+
+export class YouComClient {
+  private readonly apiKey: string;
+  private readonly searchBaseUrl: string;
+  private readonly researchBaseUrl: string;
+
+  constructor(config: YouComConfig) {
+    if (!config.apiKey) {
+      throw new Error('API key is required');
+    }
+    this.apiKey = config.apiKey;
+    this.searchBaseUrl = (config.searchBaseUrl || DEFAULT_SEARCH_BASE_URL).replace(/\/$/, '');
+    this.researchBaseUrl = (config.researchBaseUrl || DEFAULT_RESEARCH_BASE_URL).replace(/\/$/, '');
+  }
+
+  getSearchBaseUrl(): string {
+    return this.searchBaseUrl;
+  }
+
+  getResearchBaseUrl(): string {
+    return this.researchBaseUrl;
+  }
+
+  private buildUrl(
+    baseUrl: string,
+    path: string,
+    params?: Record<string, string | number | boolean | undefined>,
+  ): string {
+    const url = new URL(`${baseUrl}${path}`);
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+    const { method = 'GET', params, body, headers = {}, baseUrl = this.searchBaseUrl } = options;
+    const url = this.buildUrl(baseUrl, path, params);
+
+    const requestHeaders: Record<string, string> = {
+      'X-API-Key': this.apiKey,
+      Accept: 'application/json',
+      ...headers,
+    };
+
+    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);
+
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    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();
+    }
+
+    if (!response.ok) {
+      const errorMessage =
+        typeof data === 'object' && data !== null
+          ? JSON.stringify(data)
+          : String(data || response.statusText);
+      throw new YouComApiError(errorMessage, response.status);
+    }
+
+    return data as T;
+  }
+
+  async get<T>(
+    path: string,
+    params?: Record<string, string | number | boolean | undefined>,
+    baseUrl?: string,
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'GET', params, baseUrl });
+  }
+
+  async post<T>(
+    path: string,
+    body?: Record<string, unknown> | unknown[] | string | object,
+    baseUrl?: string,
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'POST', body, baseUrl });
+  }
+
+  getApiKeyPreview(): string {
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return '***';
+  }
+}

package/connectors/you-com/src/api/index.ts

@@ -0,0 +1,43 @@
+import type { YouComConfig } from '../types';
+import { YouComClient } from './client';
+import { SearchApi } from './search';
+import { ResearchApi } from './research';
+
+export class YouCom {
+  private readonly client: YouComClient;
+
+  public readonly search: SearchApi;
+  public readonly research: ResearchApi;
+
+  constructor(config: YouComConfig) {
+    this.client = new YouComClient(config);
+    this.search = new SearchApi(this.client);
+    this.research = new ResearchApi(this.client);
+  }
+
+  static fromEnv(): YouCom {
+    const apiKey = process.env.YDC_API_KEY;
+
+    if (!apiKey) {
+      throw new Error('YDC_API_KEY environment variable is required');
+    }
+
+    return new YouCom({
+      apiKey,
+      searchBaseUrl: process.env.YDC_SEARCH_BASE_URL,
+      researchBaseUrl: process.env.YDC_RESEARCH_BASE_URL,
+    });
+  }
+
+  getApiKeyPreview(): string {
+    return this.client.getApiKeyPreview();
+  }
+
+  getClient(): YouComClient {
+    return this.client;
+  }
+}
+
+export { YouComClient } from './client';
+export { SearchApi } from './search';
+export { ResearchApi } from './research';

package/connectors/you-com/src/api/research.ts

@@ -0,0 +1,28 @@
+import type { YouComClient } from './client';
+import type { ResearchCreateOptions, ResearchResponse } from '../types';
+
+export class ResearchApi {
+  constructor(private readonly client: YouComClient) {}
+
+  async create(options: ResearchCreateOptions): Promise<ResearchResponse> {
+    const body: Record<string, unknown> = {
+      input: options.input,
+    };
+
+    if (options.research_effort !== undefined) {
+      body.research_effort = options.research_effort;
+    }
+    if (options.source_control !== undefined) {
+      body.source_control = options.source_control;
+    }
+    if (options.output_schema !== undefined) {
+      body.output_schema = options.output_schema;
+    }
+
+    return this.client.post<ResearchResponse>(
+      '/v1/research',
+      body,
+      this.client.getResearchBaseUrl(),
+    );
+  }
+}

package/connectors/you-com/src/api/search.ts

@@ -0,0 +1,45 @@
+import type { YouComClient } from './client';
+import type { SearchGetParams, SearchPostBody, SearchResponse } from '../types';
+
+export class SearchApi {
+  constructor(private readonly client: YouComClient) {}
+
+  async get(params: SearchGetParams): Promise<SearchResponse> {
+    const queryParams: Record<string, string | number | boolean | undefined> = {
+      query: params.query,
+    };
+
+    if (params.count !== undefined) queryParams.count = params.count;
+    if (params.freshness !== undefined) queryParams.freshness = params.freshness;
+    if (params.offset !== undefined) queryParams.offset = params.offset;
+    if (params.country !== undefined) queryParams.country = params.country;
+    if (params.language !== undefined) queryParams.language = params.language;
+    if (params.safesearch !== undefined) queryParams.safesearch = params.safesearch;
+    if (params.livecrawl !== undefined) queryParams.livecrawl = params.livecrawl;
+    if (params.crawl_timeout !== undefined) queryParams.crawl_timeout = params.crawl_timeout;
+    if (params.include_domains !== undefined) queryParams.include_domains = params.include_domains;
+    if (params.exclude_domains !== undefined) queryParams.exclude_domains = params.exclude_domains;
+    if (params.boost_domains !== undefined) queryParams.boost_domains = params.boost_domains;
+
+    if (params.livecrawl_formats !== undefined) {
+      const formats = Array.isArray(params.livecrawl_formats)
+        ? params.livecrawl_formats.join(',')
+        : params.livecrawl_formats;
+      queryParams.livecrawl_formats = formats;
+    }
+
+    return this.client.get<SearchResponse>(
+      '/v1/search',
+      queryParams,
+      this.client.getSearchBaseUrl(),
+    );
+  }
+
+  async post(body: SearchPostBody): Promise<SearchResponse> {
+    return this.client.post<SearchResponse>(
+      '/v1/search',
+      { ...body },
+      this.client.getSearchBaseUrl(),
+    );
+  }
+}