@nordsym/apiclaw 2.2.0 → 2.2.1

package/src/intelligent-gateway.ts

@@ -1,339 +0,0 @@
-/**
- * APIClaw Intelligent Gateway - Capability Resolver
- *
- * Routes natural-language intents and capability queries to the best
- * matching providers from the 25k+ generated provider registry.
- */
-
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-interface GeneratedActionParam {
-  name: string;
-  in: 'path' | 'query' | 'header' | 'body' | string;
-  required?: boolean;
-  type?: string;
-}
-
-interface GeneratedAction {
-  method: 'GET' | 'POST';
-  pathTemplate: string;
-  operationId?: string;
-  summary?: string;
-  params?: GeneratedActionParam[];
-  requiresAuth?: boolean;
-  capabilities?: string[];
-  capabilityPrimary?: string;
-}
-
-interface GeneratedProvider {
-  id: string;
-  name: string;
-  description: string;
-  baseUrl: string;
-  host: string;
-  source: string;
-  sourceUrl: string;
-  callable: boolean;
-  matchKind: string;
-  matchConfidence: number;
-  actionCount: number;
-  actions: Record<string, GeneratedAction>;
-  capabilitySummary?: string[];
-}
-
-interface GeneratedArtifact {
-  version: number;
-  generatedAt: number;
-  providerCount: number;
-  callableCount: number;
-  providers: GeneratedProvider[];
-}
-
-// ---------------------------------------------------------------------------
-// Public interfaces
-// ---------------------------------------------------------------------------
-
-export interface ResolvedProvider {
-  providerId: string;
-  providerName: string;
-  baseUrl: string;
-  capability: string;
-  matchedActions: {
-    actionId: string;
-    method: string;
-    pathTemplate: string;
-    summary: string;
-    capabilities: string[];
-  }[];
-  score: number;
-  callable: boolean;
-}
-
-export interface CapabilityInfo {
-  capability: string;
-  providerCount: number;
-  actionCount: number;
-}
-
-export interface VersatileProvider {
-  providerId: string;
-  name: string;
-  capabilities: string[];
-  actionCount: number;
-}
-
-// ---------------------------------------------------------------------------
-// Data loader (cached)
-// ---------------------------------------------------------------------------
-
-let cachedArtifact: GeneratedArtifact | null = null;
-
-function loadArtifact(): GeneratedArtifact {
-  if (cachedArtifact) return cachedArtifact;
-  try {
-    cachedArtifact = require('./registry/generated-providers.json') as GeneratedArtifact;
-  } catch {
-    cachedArtifact = {
-      version: 1,
-      generatedAt: 0,
-      providerCount: 0,
-      callableCount: 0,
-      providers: [],
-    };
-  }
-  return cachedArtifact;
-}
-
-// ---------------------------------------------------------------------------
-// Keyword matching helpers
-// ---------------------------------------------------------------------------
-
-function containsKeyword(text: string, keyword: string): boolean {
-  return text.toLowerCase().includes(keyword.toLowerCase());
-}
-
-function countKeywordHits(text: string, keywords: string[]): number {
-  let hits = 0;
-  const lower = text.toLowerCase();
-  for (const kw of keywords) {
-    if (lower.includes(kw.toLowerCase())) hits++;
-  }
-  return hits;
-}
-
-// ---------------------------------------------------------------------------
-// resolveCapability
-// ---------------------------------------------------------------------------
-
-export function resolveCapability(
-  capability: string,
-  keywords?: string[],
-  opts?: { limit?: number; callableOnly?: boolean },
-): ResolvedProvider[] {
-  const limit = opts?.limit ?? 10;
-  const callableOnly = opts?.callableOnly ?? true;
-  const artifact = loadArtifact();
-  const capLower = capability.toLowerCase();
-  const kws = keywords?.map(k => k.toLowerCase()) ?? [];
-
-  const results: ResolvedProvider[] = [];
-
-  for (const provider of artifact.providers) {
-    // Filter callable
-    if (callableOnly && !provider.callable) continue;
-
-    // Capability must be in capabilitySummary
-    const caps = provider.capabilitySummary ?? [];
-    if (!caps.some(c => c.toLowerCase() === capLower)) continue;
-
-    // Find matching actions (actions whose capabilities include the requested one)
-    const matchedActions: ResolvedProvider['matchedActions'] = [];
-    for (const [actionId, action] of Object.entries(provider.actions)) {
-      const actionCaps = action.capabilities ?? [];
-      if (actionCaps.some(c => c.toLowerCase() === capLower)) {
-        matchedActions.push({
-          actionId,
-          method: action.method,
-          pathTemplate: action.pathTemplate,
-          summary: action.summary ?? '',
-          capabilities: actionCaps,
-        });
-      }
-    }
-
-    // Score — rewards relevance density, not raw volume
-    let rawScore = 0;
-
-    if (kws.length > 0) {
-      // Keyword hits in provider name + description (strongest signal)
-      const nameDescText = `${provider.name} ${provider.description}`.toLowerCase();
-      const nameHits = kws.filter(kw => nameDescText.includes(kw)).length;
-      rawScore += (nameHits / kws.length) * 0.4; // up to 0.4 for name/desc match
-
-      // Keyword density in MATCHED actions only (not all actions)
-      if (matchedActions.length > 0) {
-        const matchedText = matchedActions
-          .map(a => `${a.summary} ${a.actionId} ${a.pathTemplate}`)
-          .join(' ')
-          .toLowerCase();
-        const actionHits = kws.filter(kw => matchedText.includes(kw)).length;
-        rawScore += (actionHits / kws.length) * 0.2; // up to 0.2
-      }
-    } else {
-      // No keywords — base capability match
-      rawScore += 0.3;
-    }
-
-    // Callable bonus (verified working)
-    if (provider.callable) rawScore += 0.25;
-
-    // Action richness for this capability (more matched actions = more useful)
-    const actionRatio = Math.min(matchedActions.length / 5, 1);
-    rawScore += actionRatio * 0.1;
-
-    // Penalize mock/sandbox servers
-    const urlLower = provider.baseUrl.toLowerCase();
-    if (urlLower.includes('virtserver') || urlLower.includes('sandbox') || urlLower.includes('.local')) {
-      rawScore *= 0.5;
-    }
-
-    // Normalize to 0-1
-    const score = Math.min(1, rawScore);
-
-    results.push({
-      providerId: provider.id,
-      providerName: provider.name,
-      baseUrl: provider.baseUrl,
-      capability,
-      matchedActions,
-      score: Math.round(score * 1000) / 1000,
-      callable: provider.callable,
-    });
-  }
-
-  // Sort by score descending
-  results.sort((a, b) => b.score - a.score);
-
-  return results.slice(0, limit);
-}
-
-// ---------------------------------------------------------------------------
-// findProviderForIntent
-// ---------------------------------------------------------------------------
-
-const CAPABILITY_WORDS = new Set([
-  'lookup', 'search', 'list', 'convert', 'validate', 'generate',
-  'monitor', 'price', 'enrich', 'analyze', 'send', 'compute',
-  'stream', 'create', 'update',
-]);
-
-const STOP_WORDS = new Set([
-  'i', 'need', 'to', 'a', 'an', 'the', 'want', 'can', 'you',
-  'please', 'me', 'find', 'get', 'do', 'make', 'help', 'with',
-  'for', 'from', 'this', 'that',
-]);
-
-export function findProviderForIntent(intentText: string): ResolvedProvider[] {
-  const tokens = intentText
-    .toLowerCase()
-    .replace(/[^a-z0-9\s]/g, '')
-    .split(/\s+/)
-    .filter(t => t.length > 0);
-
-  const capabilities: string[] = [];
-  const keywords: string[] = [];
-
-  for (const token of tokens) {
-    if (CAPABILITY_WORDS.has(token)) {
-      capabilities.push(token);
-    } else if (!STOP_WORDS.has(token)) {
-      keywords.push(token);
-    }
-  }
-
-  // Default capability if none extracted
-  if (capabilities.length === 0) {
-    capabilities.push('search');
-  }
-
-  // Merge results from all detected capabilities, dedup by providerId
-  const seen = new Set<string>();
-  const merged: ResolvedProvider[] = [];
-
-  for (const cap of capabilities) {
-    const results = resolveCapability(cap, keywords, { limit: 20, callableOnly: false });
-    for (const r of results) {
-      if (!seen.has(r.providerId)) {
-        seen.add(r.providerId);
-        merged.push(r);
-      }
-    }
-  }
-
-  // Re-sort and limit
-  merged.sort((a, b) => b.score - a.score);
-  return merged.slice(0, 10);
-}
-
-// ---------------------------------------------------------------------------
-// listCapabilities
-// ---------------------------------------------------------------------------
-
-export function listCapabilities(): CapabilityInfo[] {
-  const artifact = loadArtifact();
-  const capMap = new Map<string, { providerCount: number; actionCount: number }>();
-
-  for (const provider of artifact.providers) {
-    const counted = new Set<string>();
-    for (const action of Object.values(provider.actions)) {
-      const actionCaps = action.capabilities ?? [];
-      for (const cap of actionCaps) {
-        const entry = capMap.get(cap) ?? { providerCount: 0, actionCount: 0 };
-        entry.actionCount++;
-        if (!counted.has(cap)) {
-          entry.providerCount++;
-          counted.add(cap);
-        }
-        capMap.set(cap, entry);
-      }
-    }
-  }
-
-  const result: CapabilityInfo[] = [];
-  for (const [capability, stats] of capMap) {
-    result.push({ capability, ...stats });
-  }
-
-  result.sort((a, b) => b.actionCount - a.actionCount);
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// findVersatileProviders
-// ---------------------------------------------------------------------------
-
-export function findVersatileProviders(minCapabilities: number): VersatileProvider[] {
-  const artifact = loadArtifact();
-  const results: VersatileProvider[] = [];
-
-  for (const provider of artifact.providers) {
-    const caps = provider.capabilitySummary ?? [];
-    if (caps.length >= minCapabilities) {
-      results.push({
-        providerId: provider.id,
-        name: provider.name,
-        capabilities: caps,
-        actionCount: provider.actionCount,
-      });
-    }
-  }
-
-  results.sort((a, b) => b.capabilities.length - a.capabilities.length || b.actionCount - a.actionCount);
-  return results;
-}

package/src/mcp-analytics.ts

@@ -1,156 +0,0 @@
-/**
- * APIClaw Analytics - Track all API usage
- * Both Direct Call and Open API calls are logged here
- */
-
-import { appendFileSync, existsSync, mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { ConvexHttpClient } from 'convex/browser';
-import { api } from './types/convex-api.js';
-
-export interface APICallLog {
-  timestamp: string;
-  provider: string;
-  action: string;
-  type: 'direct' | 'open';
-  userId?: string;
-  success: boolean;
-  latencyMs?: number;
-  error?: string;
-  metadata?: {
-    product?: string;
-    [key: string]: any;
-  };
-}
-
-// Log directory
-const LOG_DIR = join(homedir(), '.apiclaw', 'logs');
-const LOG_FILE = join(LOG_DIR, 'api-calls.jsonl');
-
-// Convex client (lazy init)
-let convexClient: ConvexHttpClient | null = null;
-
-function getConvexClient(): ConvexHttpClient | null {
-  if (convexClient) return convexClient;
-  
-  const convexUrl = process.env.APICLAW_CONVEX_URL || process.env.NEXT_PUBLIC_CONVEX_URL;
-  if (!convexUrl) return null;
-  
-  try {
-    convexClient = new ConvexHttpClient(convexUrl);
-    return convexClient;
-  } catch (e) {
-    console.error('[APIClaw Analytics] Failed to init Convex client:', e);
-    return null;
-  }
-}
-
-// Ensure log directory exists
-function ensureLogDir(): void {
-  if (!existsSync(LOG_DIR)) {
-    mkdirSync(LOG_DIR, { recursive: true });
-  }
-}
-
-/**
- * Log an API call to local file AND Convex
- */
-export function logAPICall(log: APICallLog): void {
-  // 1. Local file (existing behavior)
-  try {
-    ensureLogDir();
-    const line = JSON.stringify(log) + '\n';
-    appendFileSync(LOG_FILE, line);
-  } catch (e) {
-    console.error('[APIClaw Analytics] Failed to log to file:', e);
-  }
-  
-  // 2. Send to Convex (new - includes anonymous usage)
-  sendToConvex(log).catch(() => {}); // Fire and forget
-}
-
-/**
- * Send analytics event to Convex
- * Works for both authenticated and anonymous users
- */
-async function sendToConvex(log: APICallLog): Promise<void> {
-  const client = getConvexClient();
-  if (!client) return;
-  
-  try {
-    await client.mutation(api.analytics.log, {
-      event: 'api_call',
-      provider: log.provider,
-      query: log.action, // Store action as query field
-      identifier: log.userId || 'anonymous',
-      metadata: {
-        type: log.type,
-        success: log.success,
-        latencyMs: log.latencyMs,
-        error: log.error,
-        timestamp: log.timestamp,
-        ...log.metadata, // Include product and any other metadata
-      },
-    });
-  } catch (e) {
-    // Silent fail - don't break API calls for logging errors
-    console.error('[APIClaw Analytics] Failed to send to Convex:', e);
-  }
-}
-
-/**
- * Webhook for real-time analytics (optional)
- * Set APICLAW_ANALYTICS_WEBHOOK env var to enable
- */
-export async function sendToWebhook(log: APICallLog): Promise<void> {
-  const webhookUrl = process.env.APICLAW_ANALYTICS_WEBHOOK;
-  if (!webhookUrl) return;
-
-  try {
-    await fetch(webhookUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(log),
-    });
-  } catch (e) {
-    // Silent fail
-  }
-}
-
-/**
- * Track API call with timing
- */
-export async function trackAPICall<T>(
-  provider: string,
-  action: string,
-  type: 'direct' | 'open',
-  userId: string | undefined,
-  fn: () => Promise<T>
-): Promise<T> {
-  const start = Date.now();
-  let success = true;
-  let error: string | undefined;
-
-  try {
-    return await fn();
-  } catch (e: any) {
-    success = false;
-    error = e.message;
-    throw e;
-  } finally {
-    const log: APICallLog = {
-      timestamp: new Date().toISOString(),
-      provider,
-      action,
-      type,
-      userId,
-      success,
-      latencyMs: Date.now() - start,
-      error,
-    };
-
-    logAPICall(log);
-    sendToWebhook(log).catch(() => {}); // Fire and forget
-  }
-}

package/src/metered.ts

@@ -1,149 +0,0 @@
-/**
- * APIClaw Metered Billing - Pay-per-call execution wrapper
- * 
- * Usage:
- * 1. Customer signs up with metered subscription
- * 2. Each API call via executeMetered() reports usage to Stripe
- * 3. Customer is billed at end of billing period based on usage
- */
-
-import { executeAPICall } from './execute.js';
-import { reportUsage, hasActiveMeteredSubscription, METERED_BILLING } from './stripe.js';
-
-interface MeteredResult {
-  success: boolean;
-  provider: string;
-  action: string;
-  data?: unknown;
-  error?: string;
-  cost?: number;
-  billing?: {
-    tracked: boolean;
-    customerId?: string;
-    pricePerCall: number;
-  };
-}
-
-interface MeteredOptions {
-  /** Stripe customer ID for usage tracking */
-  customerId?: string;
-  /** Skip usage reporting (for testing/free tier) */
-  skipBilling?: boolean;
-  /** Provider-specific API key (Direct Call mode) */
-  customerKey?: string;
-  /** User ID for dynamic providers */
-  userId?: string;
-}
-
-/**
- * Execute an API call with metered billing tracking
- * 
- * If customerId is provided and has active metered subscription,
- * usage is reported to Stripe after successful execution.
- */
-export async function executeMetered(
-  providerId: string,
-  action: string,
-  params: Record<string, unknown>,
-  options: MeteredOptions = {}
-): Promise<MeteredResult> {
-  const { customerId, skipBilling, customerKey, userId } = options;
-
-  // Execute the API call
-  const result = await executeAPICall(
-    providerId,
-    action,
-    params,
-    userId,
-    customerKey
-  );
-
-  // Build response
-  const response: MeteredResult = {
-    ...result,
-    billing: {
-      tracked: false,
-      pricePerCall: METERED_BILLING.pricePerCall,
-    },
-  };
-
-  // Skip billing if requested or no customer
-  if (skipBilling || !customerId) {
-    return response;
-  }
-
-  // Skip billing for failed calls
-  if (!result.success) {
-    return response;
-  }
-
-  // Check for active metered subscription
-  const subscription = await hasActiveMeteredSubscription(customerId);
-  if (!subscription.active) {
-    console.log(`Customer ${customerId} has no active metered subscription`);
-    return response;
-  }
-
-  // Report usage to Stripe meter
-  const usageReport = await reportUsage(
-    customerId,
-    1,
-    `${customerId}_${providerId}_${action}_${Date.now()}`
-  );
-
-  if (usageReport.success) {
-    response.billing = {
-      tracked: true,
-      customerId,
-      pricePerCall: METERED_BILLING.pricePerCall,
-    };
-  } else {
-    console.error(`Failed to report usage for ${customerId}:`, usageReport.error);
-  }
-
-  return response;
-}
-
-/**
- * Execute multiple API calls in batch with usage tracking
- */
-export async function executeMeteredBatch(
-  calls: Array<{
-    provider: string;
-    action: string;
-    params: Record<string, unknown>;
-  }>,
-  options: MeteredOptions = {}
-): Promise<MeteredResult[]> {
-  const results = await Promise.all(
-    calls.map((call) =>
-      executeMetered(call.provider, call.action, call.params, options)
-    )
-  );
-
-  return results;
-}
-
-/**
- * Calculate estimated cost for a number of API calls
- */
-export function estimateCost(callCount: number): {
-  calls: number;
-  pricePerCall: number;
-  totalCost: number;
-  currency: string;
-} {
-  return {
-    calls: callCount,
-    pricePerCall: METERED_BILLING.pricePerCall,
-    totalCost: callCount * METERED_BILLING.pricePerCall,
-    currency: 'USD',
-  };
-}
-
-/**
- * Get metered billing configuration
- */
-export function getMeteredConfig(): typeof METERED_BILLING {
-  return METERED_BILLING;
-}