ccjk 12.0.6 → 12.0.7

package/dist/index.mjs

@@ -1,3 +1,9 @@
+import { a as createCloudClient } from './shared/ccjk.B364Fu0N.mjs';
+export { C as CachedCloudClient, b as CloudCache, d as CloudClient, F as FallbackCloudClient, R as RetryableCloudClient, T as TelemetryReporter, c as createCompleteCloudClient, g as getTelemetry, i as initializeTelemetry, r as retryUtils, s as stopTelemetry, t as telemetryUtils, e as trackEvent, w as withRetry } from './shared/ccjk.B364Fu0N.mjs';
+export { C as CloudError, a as CloudErrorCode, b as CloudErrorFactory, f as formatErrorForLogging, g as getRetryDelay, h as handleCloudError, i as isAuthError, c as isRateLimitError, d as isRetryableError, e as isRetryableErrorCode } from './shared/ccjk.D8ZLYSZZ.mjs';
+export { T as TemplatesClient, a as createTemplatesClient, g as getTemplatesClient } from './shared/ccjk.UIvifqNE.mjs';
+import { e as extractString } from './shared/ccjk.C2jHOZVP.mjs';
+export { a as extractDisplayName, i as i18nHelpers, n as normalizeRecommendation, b as normalizeRecommendations } from './shared/ccjk.C2jHOZVP.mjs';
 import { exec, execSync, spawn } from 'node:child_process';
 import { promises, existsSync, readdirSync, readFileSync, statSync, createReadStream } from 'node:fs';
 import * as os from 'node:os';
@@ -8,14 +14,15 @@ import a from './chunks/index2.mjs';
 import { g as getRuntimeVersion } from './shared/ccjk.gDEDGD_t.mjs';
 import { j as join$1 } from './shared/ccjk.bQ7Dh1g4.mjs';
 export { j as config } from './chunks/config.mjs';
-export { e as extractDisplayName, a as extractString, i as i18nHelpers, n as normalizeRecommendation, b as normalizeRecommendations } from './shared/ccjk.AqnXPAzw.mjs';
 export { a as loggerUtils } from './shared/ccjk.DG_o24cZ.mjs';
 export { p as platform } from './chunks/platform.mjs';
 import { Transform } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import './shared/ccjk.BAGoDD49.mjs';
-import 'node:process';
 import 'node:url';
+import 'node:crypto';
+import './chunks/index5.mjs';
+import 'node:process';
+import './shared/ccjk.BAGoDD49.mjs';
 import './shared/ccjk.RyizuzOI.mjs';
 import './chunks/index3.mjs';
 import 'node:readline';
@@ -26,16 +33,14 @@ import './shared/ccjk.Cjgrln_h.mjs';
 import 'tty';
 import 'fs';
 import 'child_process';
-import 'node:crypto';
 import 'buffer';
 import 'string_decoder';
 import './chunks/constants.mjs';
-import './chunks/index5.mjs';
 import './chunks/claude-config.mjs';
 import './chunks/json-config.mjs';
 import './chunks/fs-operations.mjs';
 import 'node:fs/promises';
-import './shared/ccjk.BiCrMV5O.mjs';
+import './shared/ccjk.DXRAZcix.mjs';
 import './chunks/main.mjs';
 import 'module';
 
@@ -3605,4 +3610,1332 @@ function assert(condition, message) {
   }
 }
 
-export { AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, InternalError, Logger, Mutex, NotFoundError, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, index$6 as array, assert, assertDefined, index$5 as async, batchProcessFiles, camelCase, capitalize, chunk, index$4 as command, commandExists, copyFile, countLines, createConfigManager, createLogger, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, flatten, flatten$1 as flattenArray, formatError, index$2 as fs, generateCompactWelcome, generateRecommendations, generateWelcome, get, getArchitecture, getCacheDir, getCapabilitiesByType, getCapability, getCommandPath, getCommandVersion, getConfigDir, getDataDir, getErrorMessage, getFileInfo, getFileSize, getHomeDir, getPlatform, getPlatformInfo, getRegistry, getTempDir, has, intersection, isArray, isBoolean, isDefined, isDirectory, isEmail, isFile, isLargeFile, isLinux, isMacOS, isNumber, isObject, isString, isURL, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, moveFile, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, processLargeFile, processLineByLine, readFile, readJSON, retry, scanCapabilities, sequence, set, shuffle, sleep, slugify, snakeCase, streamJSON, streamWriteJSON, index as string, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, union, unique, validation, validators, waitFor, wrapError, writeFile, writeJSON };
+async function getCloudRecommendedHooks(projectInfo, options = {}) {
+  const { includeCommunity = true, includePremium = false, limit = 10 } = options;
+  try {
+    const recommendations = await fetchCloudRecommendations(projectInfo, {
+      includeCommunity,
+      includePremium,
+      limit
+    });
+    return recommendations;
+  } catch (error) {
+    console.error("Failed to fetch cloud recommendations:", error);
+    return [];
+  }
+}
+async function fetchCloudRecommendations(projectInfo, options) {
+  const recommendations = [];
+  const baseRecommendations = getBaseRecommendations(projectInfo);
+  recommendations.push(...baseRecommendations);
+  if (projectInfo.frameworks?.length > 0) {
+    const frameworkRecs = getFrameworkRecommendations(projectInfo);
+    recommendations.push(...frameworkRecs);
+  }
+  if (projectInfo.configFiles?.length > 0) {
+    const toolRecs = getToolRecommendations(projectInfo);
+    recommendations.push(...toolRecs);
+  }
+  let filtered = recommendations;
+  if (!options.includeCommunity) {
+    filtered = filtered.filter((r) => r.metadata?.tags?.includes("official"));
+  }
+  if (!options.includePremium) {
+    filtered = filtered.filter((r) => !r.metadata?.tags?.includes("premium"));
+  }
+  if (options.limit > 0) {
+    filtered = filtered.slice(0, options.limit);
+  }
+  filtered.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  return filtered;
+}
+function getBaseRecommendations(projectInfo) {
+  const recommendations = [];
+  const projectType = projectInfo.projectType.toLowerCase();
+  if (projectType.includes("typescript") || projectType.includes("javascript")) {
+    recommendations.push(
+      {
+        name: "cloud-pre-commit-security",
+        description: "Advanced security scanning (Cloud)",
+        type: "pre-commit",
+        category: "pre-commit",
+        projectTypes: ["typescript", "javascript"],
+        trigger: {
+          matcher: "git:pre-commit"
+        },
+        action: {
+          command: "ccjk-cloud",
+          args: ["scan", "security", "--staged"],
+          timeout: 6e4
+        },
+        enabled: true,
+        priority: 200,
+        metadata: {
+          tags: ["official", "security", "cloud"],
+          version: "1.0.0"
+        }
+      },
+      {
+        name: "cloud-dependency-check",
+        description: "Check for vulnerable dependencies",
+        type: "pre-commit",
+        category: "pre-commit",
+        projectTypes: ["typescript", "javascript"],
+        trigger: {
+          matcher: "git:pre-commit",
+          condition: "package-lock.json || yarn.lock || pnpm-lock.yaml"
+        },
+        action: {
+          command: "ccjk-cloud",
+          args: ["audit", "dependencies"],
+          timeout: 3e4
+        },
+        enabled: true,
+        priority: 190,
+        metadata: {
+          tags: ["official", "security", "cloud"],
+          version: "1.0.0"
+        }
+      }
+    );
+  }
+  if (projectType.includes("python")) {
+    recommendations.push(
+      {
+        name: "cloud-python-security",
+        description: "Python security analysis",
+        type: "pre-commit",
+        category: "pre-commit",
+        projectTypes: ["python"],
+        trigger: {
+          matcher: "git:pre-commit"
+        },
+        action: {
+          command: "ccjk-cloud",
+          args: ["scan", "python-security"],
+          timeout: 45e3
+        },
+        enabled: true,
+        priority: 200,
+        metadata: {
+          tags: ["official", "security", "cloud"],
+          version: "1.0.0"
+        }
+      }
+    );
+  }
+  if (projectType.includes("rust")) {
+    recommendations.push(
+      {
+        name: "cloud-rust-audit",
+        description: "Audit Rust dependencies for vulnerabilities",
+        type: "pre-commit",
+        category: "pre-commit",
+        projectTypes: ["rust"],
+        trigger: {
+          matcher: "git:pre-commit",
+          condition: "Cargo.lock"
+        },
+        action: {
+          command: "ccjk-cloud",
+          args: ["audit", "cargo"],
+          timeout: 3e4
+        },
+        enabled: true,
+        priority: 200,
+        metadata: {
+          tags: ["official", "security", "cloud"],
+          version: "1.0.0"
+        }
+      }
+    );
+  }
+  return recommendations;
+}
+function getFrameworkRecommendations(projectInfo) {
+  const recommendations = [];
+  for (const framework of projectInfo.frameworks) {
+    const frameworkName = framework.name.toLowerCase();
+    if (frameworkName.includes("react")) {
+      recommendations.push(
+        {
+          name: "cloud-react-performance",
+          description: "Analyze React bundle performance",
+          type: "post-build",
+          category: "lifecycle",
+          projectTypes: ["typescript", "javascript"],
+          trigger: {
+            matcher: "command:*build*"
+          },
+          action: {
+            command: "ccjk-cloud",
+            args: ["analyze", "react-bundle"],
+            timeout: 3e4
+          },
+          enabled: true,
+          priority: 150,
+          metadata: {
+            tags: ["official", "react", "performance", "cloud"],
+            version: "1.0.0"
+          }
+        }
+      );
+    }
+    if (frameworkName.includes("vue")) {
+      recommendations.push(
+        {
+          name: "cloud-vue-analysis",
+          description: "Vue specific code analysis",
+          type: "pre-commit",
+          category: "pre-commit",
+          projectTypes: ["typescript", "javascript"],
+          trigger: {
+            matcher: "git:pre-commit"
+          },
+          action: {
+            command: "ccjk-cloud",
+            args: ["analyze", "vue"],
+            timeout: 2e4
+          },
+          enabled: true,
+          priority: 150,
+          metadata: {
+            tags: ["official", "vue", "cloud"],
+            version: "1.0.0"
+          }
+        }
+      );
+    }
+    if (frameworkName.includes("django")) {
+      recommendations.push(
+        {
+          name: "cloud-django-checks",
+          description: "Run Django system checks",
+          type: "pre-commit",
+          category: "pre-commit",
+          projectTypes: ["python"],
+          trigger: {
+            matcher: "git:pre-commit",
+            condition: "*.py"
+          },
+          action: {
+            command: "ccjk-cloud",
+            args: ["django", "checks"],
+            timeout: 15e3
+          },
+          enabled: true,
+          priority: 150,
+          metadata: {
+            tags: ["official", "django", "cloud"],
+            version: "1.0.0"
+          }
+        }
+      );
+    }
+  }
+  return recommendations;
+}
+function getToolRecommendations(projectInfo) {
+  const recommendations = [];
+  const configFiles = projectInfo.configFiles || [];
+  if (configFiles.some((f) => f.includes("eslint"))) {
+    recommendations.push({
+      name: "cloud-eslint-advanced",
+      description: "Advanced ESLint analysis with custom rules",
+      type: "pre-commit",
+      category: "pre-commit",
+      projectTypes: ["typescript", "javascript"],
+      trigger: {
+        matcher: "git:pre-commit"
+      },
+      action: {
+        command: "ccjk-cloud",
+        args: ["lint", "eslint", "--advanced"],
+        timeout: 25e3
+      },
+      enabled: true,
+      priority: 140,
+      metadata: {
+        tags: ["official", "eslint", "cloud"],
+        version: "1.0.0"
+      }
+    });
+  }
+  if (configFiles.some((f) => f.includes("jest") || f.includes("vitest") || f.includes("mocha"))) {
+    recommendations.push({
+      name: "cloud-test-intelligence",
+      description: "Smart test execution based on changes",
+      type: "pre-commit",
+      category: "pre-commit",
+      projectTypes: ["typescript", "javascript"],
+      trigger: {
+        matcher: "git:pre-commit"
+      },
+      action: {
+        command: "ccjk-cloud",
+        args: ["test", "intelligent"],
+        timeout: 12e4
+      },
+      enabled: true,
+      priority: 160,
+      metadata: {
+        tags: ["official", "testing", "cloud", "intelligent"],
+        version: "1.0.0"
+      }
+    });
+  }
+  return recommendations;
+}
+async function submitHookAnalytics(hookName, projectInfo, result) {
+  try {
+    console.log(`Analytics: Hook ${hookName} ${result} for ${projectInfo.projectType} project`);
+  } catch (_error) {
+  }
+}
+async function getCommunityHooks(limit = 10, category) {
+  const communityHooks = [
+    {
+      name: "community-commit-emoji",
+      description: "Add emoji to commit messages based on changes",
+      type: "post-commit",
+      category: "lifecycle",
+      projectTypes: ["typescript", "javascript", "python"],
+      trigger: {
+        matcher: "git:post-commit"
+      },
+      action: {
+        command: "ccjk-community",
+        args: ["commit-emoji"],
+        timeout: 5e3
+      },
+      enabled: true,
+      priority: 100,
+      metadata: {
+        tags: ["community", "git", "fun"],
+        author: "ccjk-user-123",
+        version: "1.0.0"
+      }
+    },
+    {
+      name: "community-code-poetry",
+      description: "Generate poetry from your code",
+      type: "post-commit",
+      category: "lifecycle",
+      projectTypes: ["typescript", "javascript", "python"],
+      trigger: {
+        matcher: "git:post-commit"
+      },
+      action: {
+        command: "ccjk-community",
+        args: ["code-poetry"],
+        timeout: 1e4
+      },
+      enabled: false,
+      priority: 50,
+      metadata: {
+        tags: ["community", "fun", "ai"],
+        author: "poet-coder",
+        version: "1.0.0"
+      }
+    }
+  ];
+  let filtered = communityHooks;
+  if (category) {
+    filtered = filtered.filter((h) => h.category === category);
+  }
+  return filtered.slice(0, limit);
+}
+
+async function getCloudRecommendations(analysis) {
+  try {
+    const client = createCloudClient();
+    const response = await client.analyzeProject({
+      projectRoot: analysis.rootPath || process.cwd(),
+      dependencies: analysis.dependencies?.direct.reduce((acc, d) => {
+        acc[d.name] = d.version || "*";
+        return acc;
+      }, {})
+    });
+    return (response.recommendations || []).map((rec) => {
+      const config = rec.config;
+      return {
+        name: extractString(rec.name, rec.id || "Unknown Agent"),
+        description: extractString(rec.description, "No description available"),
+        skills: config?.skills || [],
+        mcpServers: config?.mcpServers || [],
+        persona: config?.persona,
+        capabilities: config?.capabilities || [],
+        confidence: rec.relevanceScore || 0.8,
+        reason: "Recommended by CCJK Cloud"
+      };
+    });
+  } catch (error) {
+    console.warn("Failed to get cloud recommendations:", error);
+    return [];
+  }
+}
+async function getCloudSkillRecommendations(analysis) {
+  try {
+    const client = createCloudClient();
+    const _response = await client.analyzeProject({
+      projectRoot: analysis.rootPath || process.cwd(),
+      dependencies: analysis.dependencies?.direct.reduce((acc, d) => {
+        acc[d.name] = d.version || "*";
+        return acc;
+      }, {})
+    });
+    return [];
+  } catch (error) {
+    console.warn("Failed to get cloud skill recommendations:", error);
+    return [];
+  }
+}
+async function getCloudMcpRecommendations(analysis) {
+  try {
+    const client = createCloudClient();
+    const _response = await client.analyzeProject({
+      projectRoot: analysis.rootPath || process.cwd(),
+      dependencies: analysis.dependencies?.direct.reduce((acc, d) => {
+        acc[d.name] = d.version || "*";
+        return acc;
+      }, {})
+    });
+    return [];
+  } catch (error) {
+    console.warn("Failed to get cloud MCP recommendations:", error);
+    return [];
+  }
+}
+
+const API_BASE_URL$2 = "https://api.claudehome.cn/api/v1";
+var RatingsApiErrorCode = /* @__PURE__ */ ((RatingsApiErrorCode2) => {
+  RatingsApiErrorCode2["DUPLICATE_RATING"] = "DUPLICATE_RATING";
+  RatingsApiErrorCode2["INVALID_RATING_VALUE"] = "INVALID_RATING_VALUE";
+  RatingsApiErrorCode2["SKILL_NOT_FOUND"] = "SKILL_NOT_FOUND";
+  RatingsApiErrorCode2["UNAUTHORIZED"] = "UNAUTHORIZED";
+  RatingsApiErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  RatingsApiErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+  return RatingsApiErrorCode2;
+})(RatingsApiErrorCode || {});
+class RatingsApiError extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "RatingsApiError";
+  }
+}
+function validateRating(rating) {
+  if (!Number.isInteger(rating) || rating < 1 || rating > 5) {
+    throw new RatingsApiError(
+      `Invalid rating value: ${rating}. Rating must be an integer between 1 and 5.`,
+      "INVALID_RATING_VALUE" /* INVALID_RATING_VALUE */
+    );
+  }
+}
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      searchParams.append(key, String(value));
+    }
+  }
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+async function handleResponse(response, context) {
+  if (!response.ok) {
+    let errorData = {};
+    try {
+      errorData = await response.json();
+    } catch {
+    }
+    const errorMessage = errorData.message || errorData.error || `${context} failed`;
+    const errorCode = mapHttpStatusToErrorCode(response.status, errorData.code);
+    throw new RatingsApiError(
+      errorMessage,
+      errorCode,
+      response.status,
+      errorData
+    );
+  }
+  try {
+    const data = await response.json();
+    if (data.success === false) {
+      throw new RatingsApiError(
+        data.error || `${context} failed`,
+        "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+        response.status
+      );
+    }
+    return data.data;
+  } catch (error) {
+    if (error instanceof RatingsApiError) {
+      throw error;
+    }
+    throw new RatingsApiError(
+      `Failed to parse response for ${context}`,
+      "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+      response.status
+    );
+  }
+}
+function mapHttpStatusToErrorCode(status, serverCode) {
+  if (serverCode === "DUPLICATE_RATING") {
+    return "DUPLICATE_RATING" /* DUPLICATE_RATING */;
+  }
+  switch (status) {
+    case 401:
+      return "UNAUTHORIZED" /* UNAUTHORIZED */;
+    case 404:
+      return "SKILL_NOT_FOUND" /* SKILL_NOT_FOUND */;
+    case 409:
+      return "DUPLICATE_RATING" /* DUPLICATE_RATING */;
+    case 422:
+      return "INVALID_RATING_VALUE" /* INVALID_RATING_VALUE */;
+    default:
+      return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
+  }
+}
+async function getSkillRatings(skillId, params = {}) {
+  if (!skillId || typeof skillId !== "string") {
+    throw new RatingsApiError(
+      "Skill ID is required and must be a string",
+      "INVALID_RATING_VALUE" /* INVALID_RATING_VALUE */
+    );
+  }
+  const queryString = buildQueryString({
+    page: params.page,
+    limit: params.limit,
+    sort: params.sort
+  });
+  const url = `${API_BASE_URL$2}/skills/${encodeURIComponent(skillId)}/ratings${queryString}`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+    return await handleResponse(response, "Get skill ratings");
+  } catch (error) {
+    if (error instanceof RatingsApiError) {
+      throw error;
+    }
+    throw new RatingsApiError(
+      `Network error while fetching ratings: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "NETWORK_ERROR" /* NETWORK_ERROR */
+    );
+  }
+}
+async function createRating(skillId, data, token) {
+  if (!skillId || typeof skillId !== "string") {
+    throw new RatingsApiError(
+      "Skill ID is required and must be a string",
+      "INVALID_RATING_VALUE" /* INVALID_RATING_VALUE */
+    );
+  }
+  if (!token || typeof token !== "string") {
+    throw new RatingsApiError(
+      "Authentication token is required",
+      "UNAUTHORIZED" /* UNAUTHORIZED */
+    );
+  }
+  if (!data.userId || typeof data.userId !== "string") {
+    throw new RatingsApiError(
+      "User ID is required and must be a string",
+      "INVALID_RATING_VALUE" /* INVALID_RATING_VALUE */
+    );
+  }
+  validateRating(data.rating);
+  const url = `${API_BASE_URL$2}/skills/${encodeURIComponent(skillId)}/ratings`;
+  const requestBody = {
+    userId: data.userId,
+    rating: data.rating,
+    ...data.review !== void 0 && { review: data.review }
+  };
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify(requestBody)
+    });
+    return await handleResponse(response, "Create rating");
+  } catch (error) {
+    if (error instanceof RatingsApiError) {
+      throw error;
+    }
+    throw new RatingsApiError(
+      `Network error while creating rating: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "NETWORK_ERROR" /* NETWORK_ERROR */
+    );
+  }
+}
+function isDuplicateRatingError(error) {
+  return error instanceof RatingsApiError && error.code === "DUPLICATE_RATING" /* DUPLICATE_RATING */;
+}
+function isUnauthorizedError(error) {
+  return error instanceof RatingsApiError && error.code === "UNAUTHORIZED" /* UNAUTHORIZED */;
+}
+function isSkillNotFoundError(error) {
+  return error instanceof RatingsApiError && error.code === "SKILL_NOT_FOUND" /* SKILL_NOT_FOUND */;
+}
+const ratingsApi = {
+  getSkillRatings,
+  createRating,
+  isDuplicateRatingError,
+  isUnauthorizedError,
+  isSkillNotFoundError
+};
+
+const API_BASE_URL$1 = "https://api.claudehome.cn/api/v1";
+const DEFAULT_CACHE_TTL = 5 * 60 * 1e3;
+class SkillsMarketplaceApiError extends Error {
+  /** HTTP status code */
+  status;
+  /** Error code from API response */
+  code;
+  /** Original response data */
+  data;
+  constructor(message, status, code, data) {
+    super(message);
+    this.name = "SkillsMarketplaceApiError";
+    this.status = status;
+    this.code = code;
+    this.data = data;
+  }
+}
+class ResponseCache {
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Get cached data if valid
+   * @param key - Cache key
+   * @returns Cached data or undefined if not found/expired
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    const now = Date.now();
+    if (now - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  /**
+   * Set cache entry
+   * @param key - Cache key
+   * @param data - Data to cache
+   * @param ttl - Time to live in milliseconds
+   */
+  set(key, data, ttl) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+  /**
+   * Clear all cache entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Delete a specific cache entry
+   * @param key - Cache key to delete
+   */
+  delete(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Get cache size
+   * @returns Number of cached entries
+   */
+  get size() {
+    return this.cache.size;
+  }
+}
+const responseCache = new ResponseCache();
+function generateCacheKey(endpoint, params) {
+  const sortedParams = params ? Object.keys(params).sort().reduce(
+    (acc, key) => {
+      if (params[key] !== void 0 && params[key] !== null) {
+        acc[key] = params[key];
+      }
+      return acc;
+    },
+    {}
+  ) : {};
+  return `${endpoint}:${JSON.stringify(sortedParams)}`;
+}
+function buildUrl$1(endpoint, params) {
+  const url = new URL(`${API_BASE_URL$1}${endpoint}`);
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+  }
+  return url.toString();
+}
+async function fetchApi(endpoint, params, options = {}) {
+  const { signal, cacheTtl = DEFAULT_CACHE_TTL, forceRefresh = false } = options;
+  if (cacheTtl > 0 && !forceRefresh) {
+    const cacheKey = generateCacheKey(endpoint, params);
+    const cached = responseCache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+  }
+  const url = buildUrl$1(endpoint, params);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json"
+      },
+      signal
+    });
+    if (!response.ok) {
+      let errorData;
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      let errorCode;
+      try {
+        errorData = await response.json();
+        if (typeof errorData === "object" && errorData !== null) {
+          const err = errorData;
+          if (typeof err.message === "string") {
+            errorMessage = err.message;
+          }
+          if (typeof err.code === "string") {
+            errorCode = err.code;
+          }
+        }
+      } catch {
+      }
+      throw new SkillsMarketplaceApiError(errorMessage, response.status, errorCode, errorData);
+    }
+    const data = await response.json();
+    if (cacheTtl > 0) {
+      const cacheKey = generateCacheKey(endpoint, params);
+      responseCache.set(cacheKey, data, cacheTtl);
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof SkillsMarketplaceApiError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new SkillsMarketplaceApiError("Request was cancelled", 0, "ABORT_ERROR");
+    }
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      throw new SkillsMarketplaceApiError(
+        "Network error: Unable to connect to the API",
+        0,
+        "NETWORK_ERROR"
+      );
+    }
+    throw new SkillsMarketplaceApiError(
+      error instanceof Error ? error.message : "Unknown error occurred",
+      0,
+      "UNKNOWN_ERROR"
+    );
+  }
+}
+async function getMarketplace(params = {}, options = {}) {
+  return fetchApi("/skills/marketplace", params, options);
+}
+async function searchSkills(params, options = {}) {
+  if (!params.q || params.q.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "Search query (q) is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  return fetchApi("/skills/search", params, options);
+}
+async function getSearchSuggestions(params, options = {}) {
+  if (!params.q || params.q.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "Search query (q) is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  const suggestionOptions = {
+    ...options,
+    cacheTtl: options.cacheTtl ?? 60 * 1e3
+  };
+  return fetchApi(
+    "/skills/search/suggestions",
+    params,
+    suggestionOptions
+  );
+}
+async function getTrendingKeywords(params = {}, options = {}) {
+  const trendingOptions = {
+    ...options,
+    cacheTtl: options.cacheTtl ?? 10 * 60 * 1e3
+  };
+  return fetchApi(
+    "/skills/search/trending",
+    params,
+    trendingOptions
+  );
+}
+function clearCache() {
+  responseCache.clear();
+}
+function getCacheSize() {
+  return responseCache.size;
+}
+function createAbortController() {
+  return new AbortController();
+}
+const skillsMarketplaceApi = {
+  getMarketplace,
+  searchSkills,
+  getSearchSuggestions,
+  getTrendingKeywords,
+  clearCache,
+  getCacheSize,
+  createAbortController
+};
+
+function convertConfig(config) {
+  if (!config || typeof config !== "object")
+    return void 0;
+  const obj = config;
+  if ("command" in obj || "npmPackage" in obj) {
+    return {
+      type: typeof obj.type === "string" ? obj.type : void 0,
+      command: typeof obj.command === "string" ? obj.command : void 0,
+      args: Array.isArray(obj.args) ? obj.args.filter((a) => typeof a === "string") : void 0,
+      env: typeof obj.env === "object" && obj.env ? obj.env : void 0,
+      npmPackage: typeof obj.npmPackage === "string" ? obj.npmPackage : void 0,
+      installCommand: typeof obj.installCommand === "string" ? obj.installCommand : void 0
+    };
+  }
+  if ("enabled" in obj || "triggers" in obj) {
+    return {
+      enabled: typeof obj.enabled === "boolean" ? obj.enabled : void 0,
+      priority: typeof obj.priority === "number" ? obj.priority : void 0,
+      triggers: Array.isArray(obj.triggers) ? obj.triggers.filter((t) => typeof t === "string") : void 0,
+      parameters: typeof obj.parameters === "object" && obj.parameters ? obj.parameters : void 0
+    };
+  }
+  if ("persona" in obj || "capabilities" in obj) {
+    return {
+      persona: typeof obj.persona === "string" ? obj.persona : void 0,
+      capabilities: Array.isArray(obj.capabilities) ? obj.capabilities.filter((c) => typeof c === "string") : void 0,
+      skills: Array.isArray(obj.skills) ? obj.skills.filter((s) => typeof s === "string") : void 0,
+      mcpServers: Array.isArray(obj.mcpServers) ? obj.mcpServers.filter((m) => typeof m === "string") : void 0,
+      temperature: typeof obj.temperature === "number" ? obj.temperature : void 0,
+      maxTokens: typeof obj.maxTokens === "number" ? obj.maxTokens : void 0
+    };
+  }
+  if ("when" in obj) {
+    return {
+      command: typeof obj.command === "string" ? obj.command : void 0,
+      args: Array.isArray(obj.args) ? obj.args.filter((a) => typeof a === "string") : void 0,
+      when: typeof obj.when === "string" ? obj.when : void 0,
+      enabled: typeof obj.enabled === "boolean" ? obj.enabled : void 0
+    };
+  }
+  if ("steps" in obj) {
+    return {
+      steps: Array.isArray(obj.steps) ? obj.steps.filter((s) => typeof s === "string") : void 0,
+      triggers: Array.isArray(obj.triggers) ? obj.triggers.filter((t) => typeof t === "string") : void 0,
+      conditions: typeof obj.conditions === "object" && obj.conditions ? obj.conditions : void 0
+    };
+  }
+  return void 0;
+}
+function convertParameterDefault(value) {
+  if (value === null || value === void 0)
+    return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (Array.isArray(value)) {
+    if (value.every((v) => typeof v === "string"))
+      return value;
+    if (value.every((v) => typeof v === "number"))
+      return value;
+    return null;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const converted = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (typeof v === "string" || typeof v === "number" || typeof v === "boolean")
+        converted[k] = v;
+    }
+    return converted;
+  }
+  return null;
+}
+function convertRecommendation(raw, preferredLang = "en") {
+  return {
+    id: raw.id,
+    name: typeof raw.name === "string" ? { en: raw.name } : raw.name,
+    description: typeof raw.description === "string" ? { en: raw.description } : raw.description,
+    category: raw.category,
+    relevanceScore: raw.relevanceScore,
+    installCommand: raw.installCommand,
+    config: convertConfig(raw.config),
+    tags: raw.tags,
+    dependencies: raw.dependencies
+  };
+}
+function convertTemplateParameter(raw) {
+  return {
+    name: raw.name,
+    type: raw.type,
+    required: raw.required,
+    default: convertParameterDefault(raw.default),
+    description: typeof raw.description === "string" ? { en: raw.description } : raw.description
+  };
+}
+function convertTemplate(raw, preferredLang = "en") {
+  return {
+    id: raw.id,
+    type: raw.type,
+    name: typeof raw.name === "string" ? { en: raw.name } : raw.name,
+    description: typeof raw.description === "string" ? { en: raw.description } : raw.description,
+    content: raw.content,
+    version: raw.version,
+    author: raw.author,
+    tags: raw.tags,
+    parameters: raw.parameters ? raw.parameters.map(convertTemplateParameter) : void 0,
+    createdAt: raw.createdAt,
+    updatedAt: raw.updatedAt
+  };
+}
+function convertProjectAnalysisResponse(raw, preferredLang = "en") {
+  return {
+    requestId: raw.requestId,
+    recommendations: raw.recommendations.map((r) => convertRecommendation(r, preferredLang)),
+    projectType: raw.projectType,
+    frameworks: raw.frameworks
+  };
+}
+function convertBatchTemplateResponse(raw, preferredLang = "en") {
+  const templates = {};
+  for (const [id, template] of Object.entries(raw.templates)) {
+    templates[id] = convertTemplate(template, preferredLang);
+  }
+  return {
+    requestId: raw.requestId,
+    templates,
+    notFound: raw.notFound
+  };
+}
+function validateProjectAnalysisRequest(request) {
+  const errors = [];
+  if (!request.projectRoot || typeof request.projectRoot !== "string")
+    errors.push("projectRoot is required and must be a string");
+  if (request.dependencies && typeof request.dependencies !== "object")
+    errors.push("dependencies must be an object");
+  if (request.devDependencies && typeof request.devDependencies !== "object")
+    errors.push("devDependencies must be an object");
+  if (request.language && !["en", "zh-CN"].includes(request.language))
+    errors.push('language must be "en" or "zh-CN"');
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateBatchTemplateRequest(request) {
+  const errors = [];
+  if (!Array.isArray(request.ids))
+    errors.push("ids must be an array");
+  else if (request.ids.length === 0)
+    errors.push("ids array cannot be empty");
+  else if (!request.ids.every((id) => typeof id === "string"))
+    errors.push("all ids must be strings");
+  if (request.language && !["en", "zh-CN"].includes(request.language))
+    errors.push('language must be "en" or "zh-CN"');
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateUsageReport(report) {
+  const errors = [];
+  if (!report.reportId || typeof report.reportId !== "string")
+    errors.push("reportId is required and must be a string");
+  const validMetricTypes = [
+    "template_download",
+    "recommendation_shown",
+    "recommendation_accepted",
+    "analysis_completed",
+    "error_occurred"
+  ];
+  if (!validMetricTypes.includes(report.metricType))
+    errors.push(`metricType must be one of: ${validMetricTypes.join(", ")}`);
+  if (!report.timestamp || typeof report.timestamp !== "string")
+    errors.push("timestamp is required and must be a string");
+  if (!report.ccjkVersion || typeof report.ccjkVersion !== "string")
+    errors.push("ccjkVersion is required and must be a string");
+  if (!report.nodeVersion || typeof report.nodeVersion !== "string")
+    errors.push("nodeVersion is required and must be a string");
+  if (!report.platform || typeof report.platform !== "string")
+    errors.push("platform is required and must be a string");
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function isRecommendationConfig(value) {
+  return convertConfig(value) !== void 0;
+}
+function isTelemetryEventData(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const obj = value;
+  if (typeof obj.timestamp !== "number" && typeof obj.timestamp !== "string")
+    return false;
+  return true;
+}
+function isTemplateParameterValue(value) {
+  if (value === null || value === void 0)
+    return value === null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return true;
+    const allStrings = value.every((v) => typeof v === "string");
+    const allNumbers = value.every((v) => typeof v === "number");
+    return allStrings || allNumbers;
+  }
+  if (typeof value === "object") {
+    return Object.values(value).every(
+      (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean"
+    );
+  }
+  return false;
+}
+
+const API_BASE_URL = "https://api.claudehome.cn/api/v1";
+function buildUrl(endpoint, params) {
+  const url = new URL(`${API_BASE_URL}${endpoint}`);
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.append(key, String(value));
+      }
+    });
+  }
+  return url.toString();
+}
+async function authenticatedRequest(method, endpoint, options, body) {
+  const { token, signal, timeout = 3e4 } = options;
+  const url = buildUrl(endpoint);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const requestSignal = signal || controller.signal;
+  try {
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: body ? JSON.stringify(body) : void 0,
+      signal: requestSignal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      let errorData;
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      let errorCode;
+      try {
+        errorData = await response.json();
+        if (typeof errorData === "object" && errorData !== null) {
+          const err = errorData;
+          if (typeof err.error === "string") {
+            errorMessage = err.error;
+          }
+          if (typeof err.code === "string") {
+            errorCode = err.code;
+          }
+        }
+      } catch {
+      }
+      throw new SkillsMarketplaceApiError(errorMessage, response.status, errorCode, errorData);
+    }
+    const apiResponse = await response.json();
+    if (!apiResponse.success) {
+      throw new SkillsMarketplaceApiError(
+        apiResponse.error || "Request failed",
+        response.status,
+        apiResponse.code
+      );
+    }
+    if (!apiResponse.data) {
+      throw new SkillsMarketplaceApiError(
+        "No data in response",
+        response.status,
+        "NO_DATA"
+      );
+    }
+    return apiResponse.data;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof SkillsMarketplaceApiError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new SkillsMarketplaceApiError("Request was cancelled", 0, "ABORT_ERROR");
+    }
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      throw new SkillsMarketplaceApiError(
+        "Network error: Unable to connect to the API",
+        0,
+        "NETWORK_ERROR"
+      );
+    }
+    throw new SkillsMarketplaceApiError(
+      error instanceof Error ? error.message : "Unknown error occurred",
+      0,
+      "UNKNOWN_ERROR"
+    );
+  }
+}
+async function getUserSkills(userId, options) {
+  if (!userId || userId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "User ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  return authenticatedRequest(
+    "GET",
+    `/users/${userId}/skills`,
+    options
+  );
+}
+async function installSkill(userId, request, options) {
+  if (!userId || userId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "User ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  if (!request.skillId || request.skillId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "Skill ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  return authenticatedRequest(
+    "POST",
+    `/users/${userId}/skills`,
+    options,
+    request
+  );
+}
+async function uninstallSkill(userId, skillId, options) {
+  if (!userId || userId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "User ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  if (!skillId || skillId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "Skill ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  return authenticatedRequest(
+    "DELETE",
+    `/users/${userId}/skills/${skillId}`,
+    options
+  );
+}
+async function updateSkill(userId, skillId, request, options) {
+  if (!userId || userId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "User ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  if (!skillId || skillId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "Skill ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  if (!request.isEnabled && !request.config) {
+    throw new SkillsMarketplaceApiError(
+      "At least one of isEnabled or config must be provided",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  return authenticatedRequest(
+    "PATCH",
+    `/users/${userId}/skills/${skillId}`,
+    options,
+    request
+  );
+}
+async function getRecommendations(userId, params = {}, options) {
+  if (!userId || userId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "User ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  const endpoint = `/users/${userId}/recommendations`;
+  const url = buildUrl(endpoint, params);
+  const { token, signal, timeout = 3e4 } = options;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const requestSignal = signal || controller.signal;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      signal: requestSignal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      let errorData;
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      let errorCode;
+      try {
+        errorData = await response.json();
+        if (typeof errorData === "object" && errorData !== null) {
+          const err = errorData;
+          if (typeof err.error === "string") {
+            errorMessage = err.error;
+          }
+          if (typeof err.code === "string") {
+            errorCode = err.code;
+          }
+        }
+      } catch {
+      }
+      throw new SkillsMarketplaceApiError(errorMessage, response.status, errorCode, errorData);
+    }
+    const apiResponse = await response.json();
+    if (!apiResponse.success || !apiResponse.data) {
+      throw new SkillsMarketplaceApiError(
+        apiResponse.error || "Request failed",
+        response.status,
+        apiResponse.code
+      );
+    }
+    return apiResponse.data;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof SkillsMarketplaceApiError) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new SkillsMarketplaceApiError("Request was cancelled", 0, "ABORT_ERROR");
+    }
+    if (error instanceof TypeError && error.message.includes("fetch")) {
+      throw new SkillsMarketplaceApiError(
+        "Network error: Unable to connect to the API",
+        0,
+        "NETWORK_ERROR"
+      );
+    }
+    throw new SkillsMarketplaceApiError(
+      error instanceof Error ? error.message : "Unknown error occurred",
+      0,
+      "UNKNOWN_ERROR"
+    );
+  }
+}
+async function getUserQuota(userId, options) {
+  if (!userId || userId.trim() === "") {
+    throw new SkillsMarketplaceApiError(
+      "User ID is required",
+      400,
+      "INVALID_PARAMS"
+    );
+  }
+  return authenticatedRequest(
+    "GET",
+    `/users/${userId}/quota`,
+    options
+  );
+}
+function canInstallMore(quota) {
+  return quota.remaining > 0;
+}
+function getQuotaUsagePercentage(quota) {
+  if (quota.limit === 0) {
+    return 0;
+  }
+  return Math.round(quota.used / quota.limit * 100);
+}
+function isSkillInstalled(skills, skillId) {
+  return skills.some((skill) => skill.skillId === skillId);
+}
+function getEnabledSkills(skills) {
+  return skills.filter((skill) => skill.isEnabled);
+}
+function getDisabledSkills(skills) {
+  return skills.filter((skill) => !skill.isEnabled);
+}
+function sortByUsage(skills, order = "desc") {
+  return [...skills].sort((a, b) => {
+    return order === "desc" ? b.usageCount - a.usageCount : a.usageCount - b.usageCount;
+  });
+}
+function sortByLastUsed(skills, order = "desc") {
+  return [...skills].sort((a, b) => {
+    const aTime = a.lastUsedAt ? new Date(a.lastUsedAt).getTime() : 0;
+    const bTime = b.lastUsedAt ? new Date(b.lastUsedAt).getTime() : 0;
+    return order === "desc" ? bTime - aTime : aTime - bTime;
+  });
+}
+const userSkillsApi = {
+  getUserSkills,
+  installSkill,
+  uninstallSkill,
+  updateSkill,
+  getRecommendations,
+  getUserQuota,
+  // Utility functions
+  canInstallMore,
+  getQuotaUsagePercentage,
+  isSkillInstalled,
+  getEnabledSkills,
+  getDisabledSkills,
+  sortByUsage,
+  sortByLastUsed
+};
+
+export { AiderTool, BaseCodeTool, BaseError, ClaudeCodeTool, ClineTool, CodexTool, ConfigManager, ConfigValidator, ConfigurationError, ContinueTool, CursorTool, InternalError, Logger, Mutex, NotFoundError, RatingsApiError, RatingsApiErrorCode, Semaphore, TimeoutError, ToolFactory, ToolRegistry, UnauthorizedError, ValidationError, index$6 as array, assert, assertDefined, index$5 as async, batchProcessFiles, camelCase, canInstallMore, capitalize, chunk, index$4 as command, commandExists, convertBatchTemplateResponse, convertConfig, convertParameterDefault, convertProjectAnalysisResponse, convertRecommendation, convertTemplate, convertTemplateParameter, copyFile, countLines, createCloudClient, createConfigManager, createLogger, createRating, createTool, createValidator, debounce, deepClone, deepMerge, deleteDir, deleteFile, difference, ensureDir, index$3 as error, executeCommand, executeCommandStream, exists, extractString, flatten, flatten$1 as flattenArray, formatError, index$2 as fs, generateCompactWelcome, generateRecommendations, generateWelcome, get, getArchitecture, getCacheDir, getCapabilitiesByType, getCapability, getCloudMcpRecommendations, getCloudRecommendations, getCloudRecommendedHooks, getCloudSkillRecommendations, getCommandPath, getCommandVersion, getCommunityHooks, getConfigDir, getDataDir, getDisabledSkills, getEnabledSkills, getErrorMessage, getFileInfo, getFileSize, getHomeDir, getPlatform, getPlatformInfo, getQuotaUsagePercentage, getRecommendations, getRegistry, getSkillRatings, getTempDir, getUserQuota, getUserSkills, has, installSkill, intersection, isArray, isBoolean, isDefined, isDirectory, isDuplicateRatingError, isEmail, isFile, isLargeFile, isLinux, isMacOS, isNumber, isObject, isRecommendationConfig, isSkillInstalled, isSkillNotFoundError, isString, isTelemetryEventData, isTemplateParameterValue, isURL, isUnauthorizedError, isUnix, isWindows, kebabCase, listDirs, listFiles, logger, moveFile, index$1 as object, omit, parallelLimit, partition, pascalCase, pick, processLargeFile, processLineByLine, ratingsApi, readFile, readJSON, retry, scanCapabilities, sequence, set, shuffle, skillsMarketplaceApi, sleep, slugify, snakeCase, sortByLastUsed, sortByUsage, streamJSON, streamWriteJSON, index as string, submitHookAnalytics, template, throttle, timeout, truncate, tryCatch, tryCatchAsync, unflatten, uninstallSkill, union, unique, updateSkill, userSkillsApi, validateBatchTemplateRequest, validateProjectAnalysisRequest, validateUsageReport, validation, validators, waitFor, wrapError, writeFile, writeJSON };