@hasna/connectors 1.2.1 → 1.3.1

package/connectors/connect-huggingface/src/cli/index.ts

@@ -188,55 +188,167 @@ configCmd
   });
 
 // ============================================
-// Example API Commands - Replace with HuggingFace API commands
+// Models Commands
 // ============================================
-const exampleCmd = program
-  .command('example')
-  .description('Example API commands (replace with HuggingFace commands)');
+const modelsCmd = program.command('models').description('Search and browse HuggingFace models');
 
-exampleCmd
-  .command('list')
-  .description('List resources')
-  .option('-n, --max <number>', 'Maximum results', '10')
-  .action(async (opts) => {
+modelsCmd
+  .command('search')
+  .description('Search models')
+  .argument('[query]', 'Search query')
+  .option('--task <task>', 'Filter by task (text-generation, text2text-generation, etc)')
+  .option('--library <lib>', 'Filter by library (transformers, gguf, pytorch)')
+  .option('--author <author>', 'Filter by author')
+  .option('--sort <field>', 'Sort by: likes, downloads, trending, lastModified', 'trending')
+  .option('--limit <n>', 'Max results', '20')
+  .action(async (query, opts) => {
     try {
       const client = getClient();
-      const result = await client.example.list({ maxResults: parseInt(opts.max) });
-      print(result, getFormat(exampleCmd));
-    } catch (err) {
-      error(String(err));
-      process.exit(1);
-    }
+      const results = await client.models.search({
+        search: query, filter: opts.task, library: opts.library,
+        author: opts.author, sort: opts.sort, limit: parseInt(opts.limit),
+      });
+      print(results.map(m => ({ id: m.id, task: m.pipeline_tag, library: m.library_name, downloads: m.downloads, likes: m.likes })), getFormat(modelsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
   });
 
-exampleCmd
+modelsCmd
   .command('get <id>')
-  .description('Get a resource by ID')
-  .action(async (id: string) => {
+  .description('Get model details (e.g. meta-llama/Meta-Llama-3-8B)')
+  .action(async (id) => {
     try {
       const client = getClient();
-      const result = await client.example.get(id);
-      print(result, getFormat(exampleCmd));
-    } catch (err) {
-      error(String(err));
-      process.exit(1);
-    }
+      const result = await client.models.get(id);
+      print(result, getFormat(modelsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
   });
 
-exampleCmd
-  .command('create')
-  .description('Create a new resource')
-  .requiredOption('-n, --name <name>', 'Resource name')
-  .action(async (opts) => {
+modelsCmd
+  .command('files <id>')
+  .description('List files in a model repo')
+  .action(async (id) => {
     try {
       const client = getClient();
-      const result = await client.example.create({ name: opts.name });
-      success('Resource created!');
-      print(result, getFormat(exampleCmd));
-    } catch (err) {
-      error(String(err));
-      process.exit(1);
-    }
+      const files = await client.models.files(id);
+      print(files.map(f => ({ name: f.rfilename, size: f.lfs?.size ?? f.size ?? null })), getFormat(modelsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+// ============================================
+// Inference Commands
+// ============================================
+const inferCmd = program.command('inference').description('Run model inference via HF Inference API');
+
+inferCmd
+  .command('text-generation <model>')
+  .description('Generate text from a prompt')
+  .requiredOption('--prompt <text>', 'Input prompt')
+  .option('--max-tokens <n>', 'Max new tokens', '256')
+  .option('--temperature <t>', 'Temperature', '0.7')
+  .action(async (model, opts) => {
+    try {
+      const client = getClient();
+      const results = await client.inference.textGeneration(model, opts.prompt, {
+        max_new_tokens: parseInt(opts.maxTokens), temperature: parseFloat(opts.temperature),
+      });
+      print(results, getFormat(inferCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+inferCmd
+  .command('chat <model>')
+  .description('Chat completion (for chat models)')
+  .requiredOption('--messages <json>', 'Messages JSON array')
+  .option('--max-tokens <n>', 'Max new tokens', '256')
+  .option('--temperature <t>', 'Temperature', '0.7')
+  .action(async (model, opts) => {
+    try {
+      const messages = JSON.parse(opts.messages);
+      const client = getClient();
+      const result = await client.inference.chat(model, messages, {
+        max_new_tokens: parseInt(opts.maxTokens), temperature: parseFloat(opts.temperature),
+      });
+      print(result, getFormat(inferCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+// ============================================
+// Datasets Commands
+// ============================================
+const datasetsCmd = program.command('datasets').description('Search and browse HuggingFace datasets');
+
+datasetsCmd
+  .command('search')
+  .description('Search datasets')
+  .argument('[query]', 'Search query')
+  .option('--author <author>', 'Filter by author')
+  .option('--sort <field>', 'Sort by: likes, downloads, trending', 'trending')
+  .option('--limit <n>', 'Max results', '20')
+  .action(async (query, opts) => {
+    try {
+      const client = getClient();
+      const results = await client.datasets.search({
+        search: query, author: opts.author, sort: opts.sort, limit: parseInt(opts.limit),
+      });
+      print(results.map(d => ({ id: d.id, downloads: d.downloads, likes: d.likes, tags: d.tags?.slice(0, 5) })), getFormat(datasetsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+datasetsCmd
+  .command('get <id>')
+  .description('Get dataset details')
+  .action(async (id) => {
+    try {
+      const client = getClient();
+      const result = await client.datasets.get(id);
+      print(result, getFormat(datasetsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+datasetsCmd
+  .command('preview <id>')
+  .description('Preview first N rows of a dataset')
+  .option('--split <split>', 'Dataset split', 'train')
+  .option('--rows <n>', 'Number of rows', '10')
+  .action(async (id, opts) => {
+    try {
+      const client = getClient();
+      const result = await client.datasets.preview(id, 'default', opts.split, parseInt(opts.rows));
+      print(result, getFormat(datasetsCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+// ============================================
+// Spaces Commands
+// ============================================
+const spacesCmd = program.command('spaces').description('Search and browse HuggingFace Spaces');
+
+spacesCmd
+  .command('search')
+  .description('Search spaces')
+  .argument('[query]', 'Search query')
+  .option('--author <author>', 'Filter by author')
+  .option('--sort <field>', 'Sort by: likes, trending', 'trending')
+  .option('--limit <n>', 'Max results', '20')
+  .action(async (query, opts) => {
+    try {
+      const client = getClient();
+      const results = await client.spaces.search({
+        search: query, author: opts.author, sort: opts.sort, limit: parseInt(opts.limit),
+      });
+      print(results.map(s => ({ id: s.id, sdk: s.sdk, likes: s.likes })), getFormat(spacesCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
+  });
+
+spacesCmd
+  .command('get <id>')
+  .description('Get space details')
+  .action(async (id) => {
+    try {
+      const client = getClient();
+      const result = await client.spaces.get(id);
+      print(result, getFormat(spacesCmd));
+    } catch (err) { error(String(err)); process.exit(1); }
   });
 
 // Parse and execute

package/connectors/connect-openai/src/api/images.ts

@@ -5,8 +5,20 @@ import type {
   ImageOptions,
 } from '../types';
 
+/** Models that use the new gpt-image API (different params than DALL-E) */
+const GPT_IMAGE_MODELS = ['gpt-image-1'];
+
+function isGptImage(model: string): boolean {
+  return GPT_IMAGE_MODELS.some((m) => model.startsWith(m));
+}
+
 /**
- * Images API (DALL-E)
+ * Images API — supports both DALL-E 3 and gpt-image-1
+ *
+ * gpt-image-1 differences:
+ *   - Uses `output_format` instead of `response_format`
+ *   - Does NOT support `style` parameter
+ *   - Does NOT support `response_format` parameter
  */
 export class ImagesApi {
   constructor(private readonly client: OpenAIClient) {}
@@ -18,13 +30,29 @@ export class ImagesApi {
     prompt: string,
     options: ImageOptions = {}
   ): Promise<ImageResponse> {
+    const model = options.model || 'dall-e-3';
+
+    if (isGptImage(model)) {
+      // gpt-image-1: different parameter set
+      const request: Record<string, unknown> = {
+        model,
+        prompt,
+        n: options.n || 1,
+      };
+      if (options.size !== undefined) request.size = options.size;
+      if (options.quality !== undefined) request.quality = options.quality;
+      // gpt-image-1 uses output_format, not response_format. No style param.
+      request.output_format = 'url';
+      return this.client.post<ImageResponse>('/images/generations', request);
+    }
+
+    // DALL-E 3: original parameter set
     const request: ImageGenerateRequest = {
-      model: options.model || 'dall-e-3',
+      model,
       prompt,
       n: options.n || 1,
       response_format: 'url',
     };
-
     if (options.size !== undefined) request.size = options.size;
     if (options.quality !== undefined) request.quality = options.quality;
     if (options.style !== undefined) request.style = options.style;
@@ -54,22 +82,38 @@ export class ImagesApi {
     prompt: string,
     options: Omit<ImageOptions, 'n'> = {}
   ): Promise<string> {
+    const model = options.model || 'dall-e-3';
+
+    if (isGptImage(model)) {
+      const request: Record<string, unknown> = {
+        model,
+        prompt,
+        n: 1,
+        output_format: 'b64_json',
+      };
+      if (options.size !== undefined) request.size = options.size;
+      if (options.quality !== undefined) request.quality = options.quality;
+
+      const response = await this.client.post<ImageResponse>('/images/generations', request);
+      const b64 = response.data[0]?.b64_json;
+      if (!b64) throw new Error('No image data in response');
+      return b64;
+    }
+
+    // DALL-E 3
     const request: ImageGenerateRequest = {
-      model: options.model || 'dall-e-3',
+      model,
       prompt,
       n: 1,
       response_format: 'b64_json',
     };
-
     if (options.size !== undefined) request.size = options.size;
     if (options.quality !== undefined) request.quality = options.quality;
     if (options.style !== undefined) request.style = options.style;
 
     const response = await this.client.post<ImageResponse>('/images/generations', request);
     const b64 = response.data[0]?.b64_json;
-    if (!b64) {
-      throw new Error('No image data in response');
-    }
+    if (!b64) throw new Error('No image data in response');
     return b64;
   }
 }

package/dist/db/promotions.d.ts

@@ -0,0 +1,5 @@
+import type { Database } from "bun:sqlite";
+export declare function promoteConnector(name: string, db?: Database): void;
+export declare function demoteConnector(name: string, db?: Database): boolean;
+export declare function getPromotedConnectors(db?: Database): string[];
+export declare function isPromoted(name: string, db?: Database): boolean;

package/dist/db/promotions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/db/usage.d.ts

@@ -0,0 +1,17 @@
+import type { Database } from "bun:sqlite";
+export declare function logUsage(connector: string, action: string, agentId?: string, db?: Database): void;
+export interface UsageStats {
+    connector: string;
+    total: number;
+    last7d: number;
+    last24h: number;
+}
+export declare function getUsageStats(connector: string, db?: Database): UsageStats;
+export interface TopConnector {
+    connector: string;
+    count: number;
+}
+export declare function getTopConnectors(limit?: number, days?: number, db?: Database): TopConnector[];
+/** Get usage counts as a Map for search context */
+export declare function getUsageMap(days?: number, db?: Database): Map<string, number>;
+export declare function cleanOldUsage(days?: number, db?: Database): number;

package/dist/db/usage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -7,6 +7,6 @@
  * Or use the interactive CLI:
  *   npx @hasna/connectors
  */
-export { CONNECTORS, CATEGORIES, getConnector, getConnectorsByCategory, searchConnectors, loadConnectorVersions, type ConnectorMeta, type Category, } from "./lib/registry.js";
+export { CONNECTORS, CATEGORIES, getConnector, getConnectorsByCategory, searchConnectors, loadConnectorVersions, type ConnectorMeta, type Category, type ScoredResult, type SearchContext, } from "./lib/registry.js";
 export { installConnector, installConnectors, getInstalledConnectors, removeConnector, connectorExists, getConnectorPath, getConnectorDocs, type InstallResult, type InstallOptions, type ConnectorDocs, } from "./lib/installer.js";
 export { runConnectorCommand, getConnectorOperations, getConnectorCommandHelp, getConnectorCliPath, getConnectorsWithCli, type RunResult, } from "./lib/runner.js";

package/dist/index.js

@@ -5,6 +5,94 @@ var __require = import.meta.require;
 import { existsSync, readFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+
+// src/lib/fuzzy.ts
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0)
+    return n;
+  if (n === 0)
+    return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0;j <= n; j++)
+    prev[j] = j;
+  for (let i = 1;i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function bestFuzzyScore(token, candidates, maxDistance = 2) {
+  if (token.length < 3)
+    return 0;
+  let bestDist = maxDistance + 1;
+  for (const c of candidates) {
+    if (Math.abs(token.length - c.length) > maxDistance)
+      continue;
+    const d = levenshtein(token, c);
+    if (d < bestDist)
+      bestDist = d;
+    if (d === 0)
+      return maxDistance + 1;
+  }
+  if (bestDist > maxDistance)
+    return 0;
+  return maxDistance - bestDist + 1;
+}
+
+// src/lib/synonyms.ts
+var SYNONYM_MAP = {
+  email: ["smtp", "mail", "inbox", "resend", "ses"],
+  chat: ["messaging", "im", "slack", "discord", "teams"],
+  sms: ["text", "twilio", "messaging"],
+  payment: ["billing", "invoicing", "commerce", "checkout", "stripe"],
+  payments: ["billing", "invoicing", "commerce", "checkout", "stripe"],
+  ecommerce: ["shop", "store", "commerce", "shopify"],
+  finance: ["banking", "accounting", "invoicing"],
+  crypto: ["blockchain", "web3", "wallet"],
+  ai: ["llm", "ml", "model", "gpt", "claude", "anthropic", "openai"],
+  llm: ["ai", "model", "gpt", "claude"],
+  auth: ["oauth", "sso", "login", "identity", "authentication"],
+  database: ["db", "sql", "nosql", "postgres", "mongo", "supabase"],
+  deploy: ["hosting", "infrastructure", "ci", "cd", "vercel"],
+  storage: ["files", "drive", "s3", "bucket", "upload"],
+  cloud: ["aws", "gcp", "azure", "infrastructure"],
+  api: ["rest", "graphql", "endpoint", "webhook"],
+  monitoring: ["logs", "observability", "alerting", "datadog", "sentry"],
+  ci: ["cd", "deploy", "pipeline", "github", "actions"],
+  crm: ["sales", "leads", "contacts", "hubspot", "salesforce"],
+  analytics: ["data", "metrics", "tracking", "mixpanel", "amplitude"],
+  project: ["task", "issue", "board", "jira", "linear", "asana"],
+  docs: ["documentation", "wiki", "notion", "confluence"],
+  design: ["figma", "sketch", "ui", "ux"],
+  security: ["auth", "encryption", "compliance", "vault"]
+};
+function expandQuery(tokens) {
+  const synonyms = new Set;
+  for (const token of tokens) {
+    const matches = SYNONYM_MAP[token];
+    if (matches) {
+      for (const syn of matches) {
+        if (!tokens.includes(syn))
+          synonyms.add(syn);
+      }
+    }
+    for (const [key, values] of Object.entries(SYNONYM_MAP)) {
+      if (values.includes(token) && !tokens.includes(key)) {
+        synonyms.add(key);
+      }
+    }
+  }
+  return { original: tokens, expanded: [...synonyms] };
+}
+
+// src/lib/registry.ts
 var CATEGORIES = [
   "AI & ML",
   "Developer Tools",
@@ -5923,9 +6011,152 @@ var CONNECTORS = [
 function getConnectorsByCategory(category) {
   return CONNECTORS.filter((c) => c.category === category);
 }
-function searchConnectors(query) {
-  const q = query.toLowerCase();
-  return CONNECTORS.filter((c) => c.name.toLowerCase().includes(q) || c.displayName.toLowerCase().includes(q) || c.description.toLowerCase().includes(q) || c.tags.some((t) => t.includes(q)));
+function searchConnectors(query, context) {
+  const tokens = query.toLowerCase().trim().split(/\s+/).filter(Boolean);
+  if (tokens.length === 0)
+    return [];
+  const limit = context?.limit ?? 20;
+  const installed = new Set(context?.installed ?? []);
+  const promoted = new Set(context?.promoted ?? []);
+  const usage = context?.usage ?? new Map;
+  const results = [];
+  for (const c of CONNECTORS) {
+    const nameLow = c.name.toLowerCase();
+    const displayLow = c.displayName.toLowerCase();
+    const descLow = c.description.toLowerCase();
+    const tagsLow = c.tags.map((t) => t.toLowerCase());
+    let score = 0;
+    const matchReasons = [];
+    let allTokensMatch = true;
+    for (const token of tokens) {
+      let tokenMatched = false;
+      if (nameLow === token) {
+        score += 100;
+        matchReasons.push(`name="${token}"`);
+        tokenMatched = true;
+      } else if (nameLow.includes(token)) {
+        score += 10;
+        matchReasons.push(`name~${token}`);
+        tokenMatched = true;
+      }
+      if (tagsLow.includes(token)) {
+        score += 8;
+        if (!tokenMatched)
+          matchReasons.push(`tag="${token}"`);
+        tokenMatched = true;
+      } else if (tagsLow.some((t) => t.includes(token))) {
+        score += 5;
+        if (!tokenMatched)
+          matchReasons.push(`tag~${token}`);
+        tokenMatched = true;
+      }
+      if (displayLow.includes(token)) {
+        score += 3;
+        if (!tokenMatched)
+          matchReasons.push(`display~${token}`);
+        tokenMatched = true;
+      }
+      if (descLow.includes(token)) {
+        score += 1;
+        if (!tokenMatched)
+          matchReasons.push(`desc~${token}`);
+        tokenMatched = true;
+      }
+      if (!tokenMatched && token.length >= 3) {
+        const nameFuzzy = bestFuzzyScore(token, [nameLow], 1);
+        if (nameFuzzy > 0) {
+          score += nameFuzzy * 6;
+          matchReasons.push(`fuzzy:name\u2248${token}`);
+          tokenMatched = true;
+        }
+        if (!tokenMatched) {
+          const tagFuzzy = bestFuzzyScore(token, tagsLow, 2);
+          if (tagFuzzy > 0) {
+            score += tagFuzzy * 3;
+            matchReasons.push(`fuzzy:tag\u2248${token}`);
+            tokenMatched = true;
+          }
+        }
+        if (!tokenMatched) {
+          const displayFuzzy = bestFuzzyScore(token, [displayLow], 2);
+          if (displayFuzzy > 0) {
+            score += displayFuzzy * 2;
+            matchReasons.push(`fuzzy:display\u2248${token}`);
+            tokenMatched = true;
+          }
+        }
+      }
+      if (!tokenMatched) {
+        allTokensMatch = false;
+        break;
+      }
+    }
+    if (!allTokensMatch)
+      continue;
+    const badges = [];
+    if (installed.has(c.name)) {
+      score += 50;
+      badges.push("installed");
+    }
+    if (promoted.has(c.name)) {
+      score += 30;
+      badges.push("promoted");
+    }
+    const usageCount = usage.get(c.name) ?? 0;
+    if (usageCount > 0) {
+      score += Math.min(usageCount * 2, 40);
+      if (usageCount >= 5)
+        badges.push("hot");
+    }
+    results.push({ ...c, score, matchReasons, badges });
+  }
+  const matchedNames = new Set(results.map((r) => r.name));
+  if (results.length < limit) {
+    const { expanded } = expandQuery(tokens);
+    if (expanded.length > 0) {
+      for (const c of CONNECTORS) {
+        if (matchedNames.has(c.name))
+          continue;
+        const nameLow2 = c.name.toLowerCase();
+        const tagsLow2 = c.tags.map((t) => t.toLowerCase());
+        const descLow2 = c.description.toLowerCase();
+        let synScore = 0;
+        const synReasons = [];
+        for (const syn of expanded) {
+          if (nameLow2.includes(syn)) {
+            synScore += 2;
+            synReasons.push(`syn:name~${syn}`);
+          } else if (tagsLow2.some((t) => t.includes(syn))) {
+            synScore += 1;
+            synReasons.push(`syn:tag~${syn}`);
+          } else if (descLow2.includes(syn)) {
+            synScore += 1;
+            synReasons.push(`syn:desc~${syn}`);
+          }
+        }
+        if (synScore > 0) {
+          const badges = [];
+          if (installed.has(c.name)) {
+            synScore += 50;
+            badges.push("installed");
+          }
+          if (promoted.has(c.name)) {
+            synScore += 30;
+            badges.push("promoted");
+          }
+          const usageCount = usage.get(c.name) ?? 0;
+          if (usageCount > 0) {
+            synScore += Math.min(usageCount * 2, 40);
+            if (usageCount >= 5)
+              badges.push("hot");
+          }
+          results.push({ ...c, score: synScore, matchReasons: synReasons, badges });
+        }
+      }
+    }
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, limit);
 }
 function getConnector(name) {
   return CONNECTORS.find((c) => c.name === name);

package/dist/lib/fuzzy.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Levenshtein distance for fuzzy connector search.
+ * No dependencies — pure implementation.
+ */
+/** Compute edit distance between two strings */
+export declare function levenshtein(a: string, b: string): number;
+/**
+ * Check if token fuzzy-matches target within maxDistance.
+ * Only applies to tokens >= 3 chars to avoid false positives.
+ */
+export declare function fuzzyMatch(token: string, target: string, maxDistance?: number): boolean;
+/**
+ * Find best fuzzy match score for a token against a list of candidates.
+ * Returns 0 if no match within threshold.
+ */
+export declare function bestFuzzyScore(token: string, candidates: string[], maxDistance?: number): number;

package/dist/lib/fuzzy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/registry.d.ts

@@ -13,6 +13,27 @@ export declare const CATEGORIES: readonly ["AI & ML", "Developer Tools", "Design
 export type Category = (typeof CATEGORIES)[number];
 export declare const CONNECTORS: ConnectorMeta[];
 export declare function getConnectorsByCategory(category: Category): ConnectorMeta[];
-export declare function searchConnectors(query: string): ConnectorMeta[];
+export interface SearchContext {
+    installed?: string[];
+    promoted?: string[];
+    usage?: Map<string, number>;
+}
+export interface ScoredResult extends ConnectorMeta {
+    score: number;
+    matchReasons: string[];
+    badges: string[];
+}
+/**
+ * Ranked connector search with multi-token AND, scoring, and context signals.
+ *
+ * Score formula:
+ *   relevance (name/tag/displayName/description matches)
+ *   + installed boost (+50)
+ *   + promoted boost (+30)
+ *   + usage boost (min(count * 2, 40))
+ */
+export declare function searchConnectors(query: string, context?: SearchContext & {
+    limit?: number;
+}): ScoredResult[];
 export declare function getConnector(name: string): ConnectorMeta | undefined;
 export declare function loadConnectorVersions(): void;

package/dist/lib/synonyms.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Synonym expansion for connector search.
+ * Domain-specific terms only — not a general thesaurus.
+ */
+/**
+ * Expand search tokens with domain synonyms.
+ * Returns original tokens + synonym tokens (deduplicated).
+ */
+export declare function expandQuery(tokens: string[]): {
+    original: string[];
+    expanded: string[];
+};

package/dist/lib/synonyms.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/connectors",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Open source connector library - Install API connectors with a single command",
   "type": "module",
   "bin": {