ccjk 2.0.7 → 2.0.9

package/dist/chunks/plugin-recommendation.mjs

@@ -0,0 +1,555 @@
+import { existsSync, unlinkSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { platform, homedir } from 'node:os';
+import { join } from 'pathe';
+
+const DEFAULT_TIMEOUT$1 = 3e4;
+const DEFAULT_RETRY_ATTEMPTS = 3;
+const DEFAULT_RETRY_DELAY = 1e3;
+class CloudApiClient {
+  baseUrl;
+  timeout;
+  authToken;
+  userAgent;
+  retry;
+  /**
+   * Create a new CloudApiClient instance
+   *
+   * @param config - Client configuration
+   */
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.timeout = config.timeout || DEFAULT_TIMEOUT$1;
+    this.authToken = config.authToken;
+    this.userAgent = config.userAgent || "CCJK-Client/1.0";
+    this.retry = config.retry || {
+      maxAttempts: DEFAULT_RETRY_ATTEMPTS,
+      delay: DEFAULT_RETRY_DELAY
+    };
+  }
+  // ==========================================================================
+  // Configuration Methods
+  // ==========================================================================
+  /**
+   * Set authentication token
+   *
+   * @param token - Authentication token
+   */
+  setAuthToken(token) {
+    this.authToken = token;
+  }
+  /**
+   * Clear authentication token
+   */
+  clearAuthToken() {
+    this.authToken = void 0;
+  }
+  /**
+   * Get current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Update base URL
+   *
+   * @param url - New base URL
+   */
+  setBaseUrl(url) {
+    this.baseUrl = url.replace(/\/$/, "");
+  }
+  // ==========================================================================
+  // Request Methods
+  // ==========================================================================
+  /**
+   * Make an HTTP request to the cloud service
+   *
+   * @param path - API endpoint path (e.g., '/plugins/recommend')
+   * @param options - Request options
+   * @returns API response
+   *
+   * @example
+   * ```typescript
+   * const response = await client.request<{ data: string }>('/api/endpoint', {
+   *   method: 'POST',
+   *   body: { key: 'value' },
+   *   timeout: 5000
+   * })
+   * ```
+   */
+  async request(path, options) {
+    const maxAttempts = options.retry?.maxAttempts || this.retry.maxAttempts;
+    const retryDelay = options.retry?.delay || this.retry.delay;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        return await this.executeRequest(path, options);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt === maxAttempts || this.isClientError(lastError)) {
+          break;
+        }
+        await this.sleep(retryDelay * attempt);
+      }
+    }
+    return {
+      success: false,
+      error: lastError?.message || "Request failed",
+      code: "REQUEST_FAILED"
+    };
+  }
+  /**
+   * Execute a single HTTP request
+   *
+   * @private
+   */
+  async executeRequest(path, options) {
+    const url = this.buildUrl(path, options.query);
+    const timeout = options.timeout || this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const headers = this.buildHeaders(options);
+      const response = await fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const data = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || `HTTP ${response.status}: ${response.statusText}`,
+          code: data.code || `HTTP_${response.status}`
+        };
+      }
+      return {
+        ...data,
+        success: true
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          return {
+            success: false,
+            error: "Request timeout",
+            code: "TIMEOUT"
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          code: "NETWORK_ERROR"
+        };
+      }
+      return {
+        success: false,
+        error: String(error),
+        code: "UNKNOWN_ERROR"
+      };
+    }
+  }
+  // ==========================================================================
+  // Convenience Methods
+  // ==========================================================================
+  /**
+   * Make a GET request
+   *
+   * @param path - API endpoint path
+   * @param query - Query parameters
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async get(path, query, options) {
+    return this.request(path, {
+      method: "GET",
+      query,
+      ...options
+    });
+  }
+  /**
+   * Make a POST request
+   *
+   * @param path - API endpoint path
+   * @param body - Request body
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async post(path, body, options) {
+    return this.request(path, {
+      method: "POST",
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a PUT request
+   *
+   * @param path - API endpoint path
+   * @param body - Request body
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async put(path, body, options) {
+    return this.request(path, {
+      method: "PUT",
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a DELETE request
+   *
+   * @param path - API endpoint path
+   * @param options - Additional request options
+   * @returns API response
+   */
+  async delete(path, options) {
+    return this.request(path, {
+      method: "DELETE",
+      ...options
+    });
+  }
+  // ==========================================================================
+  // Helper Methods
+  // ==========================================================================
+  /**
+   * Build full URL with query parameters
+   *
+   * @private
+   */
+  buildUrl(path, query) {
+    const url = `${this.baseUrl}${path}`;
+    if (!query || Object.keys(query).length === 0) {
+      return url;
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+      params.append(key, String(value));
+    }
+    return `${url}?${params.toString()}`;
+  }
+  /**
+   * Build request headers
+   *
+   * @private
+   */
+  buildHeaders(options) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": this.userAgent,
+      ...options.headers
+    };
+    const token = options.authToken || this.authToken;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  /**
+   * Check if error is a client error (4xx)
+   *
+   * @private
+   */
+  isClientError(error) {
+    return error.message.includes("HTTP 4");
+  }
+  /**
+   * Sleep for specified milliseconds
+   *
+   * @private
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+const CLOUD_API_BASE_URL = "https://api.claudehome.cn";
+const CACHE_DIR = join(homedir(), ".ccjk", "cache");
+const CACHE_FILE = join(CACHE_DIR, "plugin-recommendations.json");
+const CACHE_TTL = 24 * 60 * 60 * 1e3;
+const DEFAULT_TIMEOUT = 1e4;
+class PluginRecommendationService {
+  apiClient;
+  fallbackData;
+  /**
+   * Create a new PluginRecommendationService instance
+   *
+   * @param baseUrl - Cloud API base URL (default: https://api.claudehome.cn)
+   * @param fallbackData - Fallback data for offline mode
+   */
+  constructor(baseUrl = CLOUD_API_BASE_URL, fallbackData = []) {
+    this.apiClient = new CloudApiClient({
+      baseUrl,
+      timeout: DEFAULT_TIMEOUT,
+      userAgent: "CCJK-PluginRecommendation/1.0"
+    });
+    this.fallbackData = fallbackData;
+  }
+  // ==========================================================================
+  // Public Methods
+  // ==========================================================================
+  /**
+   * Get plugin recommendations
+   *
+   * Fetches recommendations from cache if available and valid,
+   * otherwise requests from cloud API with fallback to local data.
+   *
+   * @param request - Recommendation request parameters
+   * @returns Recommendation response
+   */
+  async getRecommendations(request) {
+    const cached = this.getCachedRecommendations(request);
+    if (cached) {
+      return {
+        recommendations: cached.data,
+        total: cached.data.length,
+        fromCache: true,
+        cacheTimestamp: cached.timestamp
+      };
+    }
+    try {
+      const response = await this.fetchFromCloud(request);
+      if (response.success && response.data) {
+        this.cacheRecommendations(request, response.data.recommendations);
+        return {
+          recommendations: response.data.recommendations,
+          total: response.data.total || response.data.recommendations.length,
+          fromCache: false,
+          algorithmVersion: response.data.algorithmVersion
+        };
+      }
+    } catch (error) {
+      console.warn("Cloud API request failed:", error);
+    }
+    const localRecommendations = this.getLocalRecommendations(request);
+    this.cacheRecommendations(request, localRecommendations);
+    return {
+      recommendations: localRecommendations,
+      total: localRecommendations.length,
+      fromCache: false
+    };
+  }
+  /**
+   * Clear recommendation cache
+   *
+   * Removes all cached recommendations.
+   */
+  clearCache() {
+    try {
+      if (existsSync(CACHE_FILE)) {
+        unlinkSync(CACHE_FILE);
+      }
+    } catch (error) {
+      console.warn("Failed to clear cache:", error);
+    }
+  }
+  /**
+   * Get cache status
+   *
+   * Returns information about the current cache state.
+   */
+  getCacheStatus() {
+    try {
+      if (!existsSync(CACHE_FILE)) {
+        return { exists: false };
+      }
+      const data = readFileSync(CACHE_FILE, "utf-8");
+      const cached = JSON.parse(data);
+      const isValid = new Date(cached.expiresAt).getTime() > Date.now();
+      return {
+        exists: true,
+        timestamp: cached.timestamp,
+        expiresAt: cached.expiresAt,
+        isValid
+      };
+    } catch {
+      return { exists: false };
+    }
+  }
+  /**
+   * Set fallback data
+   *
+   * Updates the local fallback data used when cloud API is unavailable.
+   *
+   * @param data - Fallback plugin recommendations
+   */
+  setFallbackData(data) {
+    this.fallbackData = data;
+  }
+  // ==========================================================================
+  // Private Methods - Cache Management
+  // ==========================================================================
+  /**
+   * Get cached recommendations if valid
+   *
+   * @private
+   */
+  getCachedRecommendations(request) {
+    try {
+      if (!existsSync(CACHE_FILE)) {
+        return null;
+      }
+      const data = readFileSync(CACHE_FILE, "utf-8");
+      const cached = JSON.parse(data);
+      if (new Date(cached.expiresAt).getTime() < Date.now()) {
+        return null;
+      }
+      if (!this.requestMatches(cached.request, request)) {
+        return null;
+      }
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Cache recommendations to disk
+   *
+   * @private
+   */
+  cacheRecommendations(request, recommendations) {
+    try {
+      if (!existsSync(CACHE_DIR)) {
+        mkdirSync(CACHE_DIR, { recursive: true });
+      }
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(now.getTime() + CACHE_TTL);
+      const cached = {
+        data: recommendations,
+        timestamp: now.toISOString(),
+        request,
+        expiresAt: expiresAt.toISOString()
+      };
+      writeFileSync(CACHE_FILE, JSON.stringify(cached, null, 2), "utf-8");
+    } catch (error) {
+      console.warn("Failed to cache recommendations:", error);
+    }
+  }
+  /**
+   * Check if two requests match for caching purposes
+   *
+   * @private
+   */
+  requestMatches(cached, current) {
+    return cached.os === current.os && cached.codeTool === current.codeTool && cached.preferredLang === current.preferredLang && cached.category === current.category && JSON.stringify(cached.userTags || []) === JSON.stringify(current.userTags || []);
+  }
+  // ==========================================================================
+  // Private Methods - Cloud API
+  // ==========================================================================
+  /**
+   * Fetch recommendations from cloud API
+   *
+   * @private
+   */
+  async fetchFromCloud(request) {
+    return this.apiClient.post("/plugins/recommend", {
+      os: request.os,
+      codeTool: request.codeTool,
+      installedPlugins: request.installedPlugins,
+      preferredLang: request.preferredLang,
+      userTags: request.userTags,
+      category: request.category,
+      limit: request.limit || 10
+    });
+  }
+  // ==========================================================================
+  // Private Methods - Local Fallback
+  // ==========================================================================
+  /**
+   * Get recommendations from local fallback data
+   *
+   * Filters and scores local plugins based on request parameters.
+   *
+   * @private
+   */
+  getLocalRecommendations(request) {
+    let recommendations = [...this.fallbackData];
+    recommendations = recommendations.filter(
+      (plugin) => plugin.compatibility.os.includes(request.os) || plugin.compatibility.os.includes("all")
+    );
+    recommendations = recommendations.filter(
+      (plugin) => plugin.compatibility.codeTools.includes(request.codeTool) || plugin.compatibility.codeTools.includes("all")
+    );
+    if (request.category) {
+      recommendations = recommendations.filter(
+        (plugin) => plugin.category === request.category
+      );
+    }
+    if (request.userTags && request.userTags.length > 0) {
+      recommendations = recommendations.filter(
+        (plugin) => request.userTags.some((tag) => plugin.tags.includes(tag))
+      );
+    }
+    recommendations = recommendations.filter(
+      (plugin) => !request.installedPlugins.includes(plugin.id)
+    );
+    recommendations = recommendations.map((plugin) => {
+      const score = this.calculateRecommendationScore(plugin, request);
+      return {
+        ...plugin,
+        recommendationScore: score
+      };
+    });
+    recommendations.sort(
+      (a, b) => (b.recommendationScore || 0) - (a.recommendationScore || 0)
+    );
+    const limit = request.limit || 10;
+    return recommendations.slice(0, limit);
+  }
+  /**
+   * Calculate recommendation score for a plugin
+   *
+   * Combines popularity, rating, and relevance to generate a score.
+   *
+   * @private
+   */
+  calculateRecommendationScore(plugin, request) {
+    let score = 0;
+    score += plugin.popularity / 100 * 40;
+    score += plugin.rating / 5 * 30;
+    if (request.userTags && request.userTags.length > 0) {
+      const matchingTags = plugin.tags.filter(
+        (tag) => request.userTags.includes(tag)
+      ).length;
+      score += matchingTags / request.userTags.length * 20;
+    } else {
+      score += 10;
+    }
+    if (plugin.verified) {
+      score += 10;
+    }
+    return Math.round(score);
+  }
+}
+let serviceInstance = null;
+function getPluginRecommendationService(fallbackData) {
+  if (!serviceInstance) {
+    serviceInstance = new PluginRecommendationService(
+      CLOUD_API_BASE_URL,
+      fallbackData
+    );
+  }
+  return serviceInstance;
+}
+async function getRecommendations(request) {
+  const service = getPluginRecommendationService();
+  return service.getRecommendations(request);
+}
+function getCurrentPlatform() {
+  const p = platform();
+  switch (p) {
+    case "darwin":
+      return "darwin";
+    case "win32":
+      return "win32";
+    case "linux":
+      return "linux";
+    default:
+      return "linux";
+  }
+}
+
+export { PluginRecommendationService, getCurrentPlatform, getPluginRecommendationService, getRecommendations };