@hasna/connectors 0.4.2 → 0.5.0

package/connectors/connect-perplexity/scripts/publish.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+/**
+ * Auto-versioning publish script
+ * - Fetches current npm version
+ * - Auto-bumps patch version if local version <= npm version
+ * - Creates git tag
+ * - Publishes to npm
+ */
+
+import { $ } from 'bun';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+interface PackageJson {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+}
+
+type BumpType = 'patch' | 'minor' | 'major';
+
+function parseVersion(version: string): { major: number; minor: number; patch: number } {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return { major, minor, patch };
+}
+
+function bumpVersion(version: string, type: BumpType = 'patch'): string {
+  const { major, minor, patch } = parseVersion(version);
+
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+    default:
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+function compareVersions(a: string, b: string): number {
+  const vA = parseVersion(a);
+  const vB = parseVersion(b);
+
+  if (vA.major !== vB.major) return vA.major - vB.major;
+  if (vA.minor !== vB.minor) return vA.minor - vB.minor;
+  return vA.patch - vB.patch;
+}
+
+async function getNpmVersion(packageName: string): Promise<string | null> {
+  try {
+    const result = await $`npm view ${packageName} version 2>/dev/null`.text();
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function hasUncommittedChanges(): Promise<boolean> {
+  try {
+    const result = await $`git status --porcelain`.text();
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function isGitRepo(): Promise<boolean> {
+  try {
+    await $`git rev-parse --git-dir 2>/dev/null`.text();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createGitTag(version: string, packageName: string): Promise<boolean> {
+  const tagName = `${packageName}@${version}`;
+
+  try {
+    // Check if tag already exists
+    const existingTags = await $`git tag -l ${tagName}`.text();
+    if (existingTags.trim()) {
+      console.log(`⚠️  Tag ${tagName} already exists, skipping tag creation`);
+      return true;
+    }
+
+    await $`git tag -a ${tagName} -m "Release ${tagName}"`;
+    console.log(`✅ Created git tag: ${tagName}`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to create git tag: ${error}`);
+    return false;
+  }
+}
+
+async function commitVersionBump(version: string, packageName: string): Promise<boolean> {
+  try {
+    await $`git add package.json`;
+    await $`git commit -m "chore(${packageName}): bump version to ${version}"`;
+    console.log(`✅ Committed version bump`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to commit: ${error}`);
+    return false;
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const bumpType = (args.find(a => ['patch', 'minor', 'major'].includes(a)) || 'patch') as BumpType;
+  const skipGit = args.includes('--skip-git');
+  const dryRun = args.includes('--dry-run');
+  const force = args.includes('--force');
+
+  // Read package.json
+  const pkgPath = join(process.cwd(), 'package.json');
+  const pkg: PackageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+
+  console.log(`\n📦 Publishing ${pkg.name}\n`);
+
+  // Get current npm version
+  const npmVersion = await getNpmVersion(pkg.name);
+  let newVersion = pkg.version;
+
+  if (npmVersion) {
+    console.log(`📌 Current npm version: ${npmVersion}`);
+    console.log(`📌 Local version: ${pkg.version}`);
+
+    // Check if we need to bump
+    if (compareVersions(pkg.version, npmVersion) <= 0) {
+      newVersion = bumpVersion(npmVersion, bumpType);
+      console.log(`🔄 Auto-bumping to: ${newVersion}`);
+    } else {
+      console.log(`✅ Local version is ahead, using: ${pkg.version}`);
+    }
+  } else {
+    console.log(`📌 Package not yet published to npm`);
+    console.log(`📌 Using local version: ${pkg.version}`);
+  }
+
+  // Update package.json if version changed
+  if (newVersion !== pkg.version) {
+    if (dryRun) {
+      console.log(`\n🧪 DRY RUN: Would update version to ${newVersion}`);
+    } else {
+      pkg.version = newVersion;
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+      console.log(`✅ Updated package.json to version ${newVersion}`);
+    }
+  }
+
+  // Git operations
+  const isGit = await isGitRepo();
+
+  if (isGit && !skipGit) {
+    const hasChanges = await hasUncommittedChanges();
+
+    if (hasChanges && newVersion !== pkg.version) {
+      if (dryRun) {
+        console.log(`🧪 DRY RUN: Would commit version bump`);
+      } else {
+        await commitVersionBump(newVersion, pkg.name.replace('@hasna/', ''));
+      }
+    }
+
+    if (dryRun) {
+      console.log(`🧪 DRY RUN: Would create tag ${pkg.name}@${newVersion}`);
+    } else {
+      await createGitTag(newVersion, pkg.name.replace('@hasna/', ''));
+    }
+  }
+
+  // Build
+  console.log(`\n🔨 Building...`);
+  if (!dryRun) {
+    await $`bun run build`;
+  } else {
+    console.log(`🧪 DRY RUN: Would run build`);
+  }
+
+  // Publish
+  console.log(`\n🚀 Publishing to npm...`);
+  if (dryRun) {
+    console.log(`🧪 DRY RUN: Would publish ${pkg.name}@${newVersion}`);
+  } else {
+    try {
+      await $`npm publish`;
+      console.log(`\n✅ Successfully published ${pkg.name}@${newVersion}`);
+    } catch (error) {
+      console.error(`\n❌ Publish failed: ${error}`);
+      process.exit(1);
+    }
+  }
+
+  // Push tags
+  if (isGit && !skipGit && !dryRun) {
+    console.log(`\n📤 Pushing tags to remote...`);
+    try {
+      await $`git push --tags`;
+      console.log(`✅ Pushed tags to remote`);
+    } catch {
+      console.log(`⚠️  Could not push tags (no remote or not configured)`);
+    }
+  }
+
+  console.log(`\n✨ Done!\n`);
+}
+
+main().catch(console.error);

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

@@ -0,0 +1,119 @@
+import type { PerplexityConfig, OutputFormat } from '../types';
+import { PerplexityApiError } from '../types';
+
+const DEFAULT_BASE_URL = 'https://api.perplexity.ai';
+
+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>;
+  format?: OutputFormat;
+}
+
+export class PerplexityClient {
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+
+  constructor(config: PerplexityConfig) {
+    if (!config.apiKey) {
+      throw new Error('API key is required');
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+  }
+
+  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+    const url = new URL(`${this.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();
+  }
+
+  /**
+   * Make an authenticated request to the Perplexity API
+   */
+  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> = {
+      'Authorization': `Bearer ${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);
+
+    // 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 PerplexityApiError(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 a preview of the API key (for display/debugging)
+   */
+  getApiKeyPreview(): string {
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return '***';
+  }
+}

package/connectors/connect-perplexity/src/api/example.ts

@@ -0,0 +1,118 @@
+import type { PerplexityClient } from './client';
+import type {
+  ChatCompletionRequest,
+  ChatCompletionResponse,
+  ChatMessage,
+  PerplexityModel,
+} from '../types';
+
+export interface ChatOptions {
+  model?: PerplexityModel;
+  maxTokens?: number;
+  temperature?: number;
+  topP?: number;
+  topK?: number;
+  presencePenalty?: number;
+  frequencyPenalty?: number;
+  searchDomainFilter?: string[];
+  returnImages?: boolean;
+  returnRelatedQuestions?: boolean;
+  searchRecencyFilter?: 'month' | 'week' | 'day' | 'hour';
+  systemPrompt?: string;
+}
+
+/**
+ * Chat Completions API
+ */
+export class ChatApi {
+  constructor(private readonly client: PerplexityClient) {}
+
+  /**
+   * Create a chat completion
+   */
+  async create(
+    messages: ChatMessage[],
+    options: ChatOptions = {}
+  ): Promise<ChatCompletionResponse> {
+    const request: ChatCompletionRequest = {
+      model: options.model || 'sonar',
+      messages,
+      stream: false,
+    };
+
+    if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+    if (options.temperature !== undefined) request.temperature = options.temperature;
+    if (options.topP !== undefined) request.top_p = options.topP;
+    if (options.topK !== undefined) request.top_k = options.topK;
+    if (options.presencePenalty !== undefined) request.presence_penalty = options.presencePenalty;
+    if (options.frequencyPenalty !== undefined) request.frequency_penalty = options.frequencyPenalty;
+    if (options.searchDomainFilter !== undefined) request.search_domain_filter = options.searchDomainFilter;
+    if (options.returnImages !== undefined) request.return_images = options.returnImages;
+    if (options.returnRelatedQuestions !== undefined) request.return_related_questions = options.returnRelatedQuestions;
+    if (options.searchRecencyFilter !== undefined) request.search_recency_filter = options.searchRecencyFilter;
+
+    return this.client.post<ChatCompletionResponse>('/chat/completions', request);
+  }
+
+  /**
+   * Simple ask method - send a single question and get an answer
+   */
+  async ask(
+    question: string,
+    options: ChatOptions = {}
+  ): Promise<ChatCompletionResponse> {
+    const messages: ChatMessage[] = [];
+
+    if (options.systemPrompt) {
+      messages.push({ role: 'system', content: options.systemPrompt });
+    }
+
+    messages.push({ role: 'user', content: question });
+
+    return this.create(messages, options);
+  }
+
+  /**
+   * Search the web and get an answer grounded in search results
+   */
+  async search(
+    query: string,
+    options: Omit<ChatOptions, 'systemPrompt'> & { recency?: 'month' | 'week' | 'day' | 'hour' } = {}
+  ): Promise<ChatCompletionResponse> {
+    const { recency, ...restOptions } = options;
+
+    return this.ask(query, {
+      ...restOptions,
+      searchRecencyFilter: recency,
+      systemPrompt: 'You are a helpful search assistant. Provide accurate, well-researched answers based on the most recent and relevant information available.',
+    });
+  }
+
+  /**
+   * Deep research on a topic
+   */
+  async research(
+    topic: string,
+    options: Omit<ChatOptions, 'model' | 'systemPrompt'> = {}
+  ): Promise<ChatCompletionResponse> {
+    return this.ask(topic, {
+      ...options,
+      model: 'sonar-deep-research',
+      systemPrompt: 'You are a research assistant. Provide comprehensive, well-cited analysis on the given topic.',
+    });
+  }
+
+  /**
+   * Reasoning task
+   */
+  async reason(
+    prompt: string,
+    options: Omit<ChatOptions, 'model' | 'systemPrompt'> = {}
+  ): Promise<ChatCompletionResponse> {
+    return this.ask(prompt, {
+      ...options,
+      model: 'sonar-reasoning-pro',
+      systemPrompt: 'You are a logical reasoning assistant. Think through problems step by step and provide well-reasoned answers.',
+    });
+  }
+}

package/connectors/connect-perplexity/src/api/index.ts

@@ -0,0 +1,48 @@
+import type { PerplexityConfig } from '../types';
+import { PerplexityClient } from './client';
+import { ChatApi } from './example';
+
+/**
+ * Perplexity AI API Client
+ */
+export class Perplexity {
+  private readonly client: PerplexityClient;
+
+  // API modules
+  public readonly chat: ChatApi;
+
+  constructor(config: PerplexityConfig) {
+    this.client = new PerplexityClient(config);
+    this.chat = new ChatApi(this.client);
+  }
+
+  /**
+   * Create a client from environment variables
+   * Looks for PERPLEXITY_API_KEY
+   */
+  static fromEnv(): Perplexity {
+    const apiKey = process.env.PERPLEXITY_API_KEY;
+
+    if (!apiKey) {
+      throw new Error('PERPLEXITY_API_KEY environment variable is required');
+    }
+    return new Perplexity({ apiKey });
+  }
+
+  /**
+   * Get a preview of the API key (for debugging)
+   */
+  getApiKeyPreview(): string {
+    return this.client.getApiKeyPreview();
+  }
+
+  /**
+   * Get the underlying client for direct API access
+   */
+  getClient(): PerplexityClient {
+    return this.client;
+  }
+}
+
+export { PerplexityClient } from './client';
+export { ChatApi } from './example';