@vdkit/cli 3.0.1 → 3.0.2

package/src/community/CommunityDeployer.js

@@ -149,20 +149,6 @@ export class CommunityDeployer {
       if (searchResults.length > 0) {
         return this.normalizeRepositoryBlueprint(searchResults[0]);
       }
-
-      // Try fuzzy search if exact match fails
-      const fuzzyResults = await searchBlueprints({
-        query: blueprintId,
-        fuzzy: true,
-        limit: 1,
-      });
-
-      if (fuzzyResults.length > 0) {
-        console.warn(
-          chalk.yellow(`Exact match not found, using similar: ${fuzzyResults[0].metadata.title}`)
-        );
-        return this.normalizeRepositoryBlueprint(fuzzyResults[0]);
-      }
     } catch (error) {
       console.warn(chalk.yellow(`Repository fetch failed: ${error.message}`));
     }
@@ -339,11 +325,13 @@ export class CommunityDeployer {
   /**
    * Deploy adapted blueprint to target platforms
    */
-  async deployToIntegrations(adaptedBlueprint, _projectContext) {
+  async deployToIntegrations(adaptedBlueprint, projectContext) {
     const deployResult = {
       success: false,
       platforms: [],
       errors: [],
+      warnings: [],
+      files: [],
     };
 
     try {
@@ -351,33 +339,70 @@ export class CommunityDeployer {
       if (!this.integrationManager) {
         this.integrationManager = createIntegrationManager(this.projectPath);
         await this.integrationManager.discoverIntegrations({ verbose: false });
-        await this.integrationManager.scanAll({ verbose: false });
+      }
+      await this.integrationManager.scanAll({ verbose: false });
+
+      if (typeof this.ruleAdapter?.adaptRules !== 'function') {
+        throw new Error('RuleAdapter does not support adaptRules() for community deployment');
       }
 
-      // Convert adapted blueprint to rule format
+      const activeIntegrations = this.integrationManager.getActiveIntegrations?.() || [];
+
+      if (activeIntegrations.length === 0) {
+        deployResult.errors.push('No active IDE integrations detected');
+        return deployResult;
+      }
+
+      // Convert adapted blueprint to standardized rule format and deploy per platform
       const rules = this.convertBlueprintToRules(adaptedBlueprint);
 
-      // Deploy using existing integration system
-      const integrationResult = await this.integrationManager.initializeActive({
-        rules: rules,
-        overwrite: true, // Community deployments should overwrite
-        verbose: false,
-      });
+      for (const integration of activeIntegrations) {
+        const platformId = this.mapIntegrationToPlatformId(integration.name);
+
+        try {
+          const adaptResult = await this.ruleAdapter.adaptRules(
+            rules,
+            platformId,
+            projectContext || adaptedBlueprint?.adaptedFor || {},
+            adaptedBlueprint?.platforms?.[platformId] || {}
+          );
+
+          if (!adaptResult?.files || adaptResult.files.length === 0) {
+            deployResult.warnings.push(`No files generated for ${integration.name}`);
+            continue;
+          }
+
+          await this.writeAdaptedFiles(adaptResult.files);
+          deployResult.files.push(...adaptResult.files);
+          deployResult.platforms.push(integration.name);
+
+          if (Array.isArray(adaptResult.warnings) && adaptResult.warnings.length > 0) {
+            deployResult.warnings.push(...adaptResult.warnings);
+          }
+        } catch (error) {
+          deployResult.errors.push(`${integration.name}: ${error.message}`);
+        }
+      }
 
-      deployResult.success = true;
-      deployResult.platforms = this.integrationManager
-        .getActiveIntegrations?.()
-        ?.map(i => i.name) || ['deployed'];
-      deployResult.errors = integrationResult.errors || [];
+      deployResult.success = deployResult.platforms.length > 0 && deployResult.errors.length === 0;
 
       // Log platform deployments
-      console.log(chalk.cyan('\n🚀 Deployed to platforms:'));
-      deployResult.platforms.forEach(platform => {
-        console.log(chalk.green(`✓ ${platform}`));
-      });
+      if (deployResult.platforms.length > 0) {
+        console.log(chalk.cyan('\n🚀 Deployed to platforms:'));
+        deployResult.platforms.forEach(platform => {
+          console.log(chalk.green(`✓ ${platform}`));
+        });
+      }
 
-      if (deployResult.errors.length > 0) {
+      if (deployResult.warnings.length > 0) {
         console.log(chalk.yellow('\nWarnings:'));
+        deployResult.warnings.forEach(warning => {
+          console.log(chalk.yellow(`  ⚠️  ${warning}`));
+        });
+      }
+
+      if (deployResult.errors.length > 0) {
+        console.log(chalk.yellow('\nErrors:'));
         deployResult.errors.forEach(error => {
           console.log(chalk.yellow(`  ⚠️  ${error}`));
         });
@@ -714,7 +739,14 @@ ${enhancement.content}
     return [
       {
         id: blueprint.metadata?.id || 'community-blueprint',
+        name: blueprint.title || 'Community Blueprint',
         title: blueprint.title || 'Community Blueprint',
+        frontmatter: {
+          description: blueprint.description || 'Community imported blueprint',
+          category: 'imported',
+          alwaysApply: false,
+          globs: [],
+        },
         content: blueprint.content,
         metadata: {
           source: 'community',
@@ -726,6 +758,50 @@ ${enhancement.content}
     ];
   }
 
+  async writeAdaptedFiles(files) {
+    const fs = await import('node:fs/promises');
+    const pathModule = await import('node:path');
+
+    for (const file of files) {
+      if (!file?.path || typeof file.content !== 'string') {
+        continue;
+      }
+
+      await fs.mkdir(pathModule.dirname(file.path), { recursive: true });
+      await fs.writeFile(file.path, file.content, 'utf8');
+    }
+  }
+
+  mapIntegrationToPlatformId(integrationName) {
+    const mapping = {
+      'Claude Code CLI': 'claude-code-cli',
+      Cursor: 'cursor',
+      Windsurf: 'windsurf',
+      'GitHub Copilot': 'github-copilot',
+      Continue: 'continue',
+      Aider: 'aider',
+      'OpenAI Codex': 'openai-codex',
+      OpenCode: 'opencode',
+      'Gemini CLI': 'gemini-cli',
+      Cline: 'cline',
+      'Roo Code': 'roo-code',
+      Goose: 'goose',
+      Junie: 'junie',
+      'Google Antigravity': 'google-antigravity',
+      'Kimi CLI': 'kimi-cli',
+      'Mistral Vibe': 'mistral-vibe',
+      Trae: 'trae',
+      'JetBrains AI': 'jetbrains-ai',
+      'VS Code Insiders': 'vscode-insiders',
+      'VS Codium': 'vscodium',
+      'Zed Editor': 'zed',
+      Zed: 'zed',
+      Tabnine: 'tabnine',
+    };
+
+    return mapping[integrationName] || integrationName.toLowerCase().replace(/\s+/g, '-');
+  }
+
   // Project analysis helper methods
   detectFramework(_projectData) {
     const packageJsonPath = path.join(this.projectPath, 'package.json');

package/src/hub/ConfigManager.js

@@ -48,7 +48,7 @@ const DEFAULT_CONFIG = {
     verbose: false,
   },
   cli: {
-    version: '2.0.0',
+    version: '3.0.1',
     sessionId: null,
     logLevel: process.env.VDK_LOG_LEVEL || 'info',
     debugMode: process.env.VDK_DEBUG === 'true',
@@ -228,7 +228,7 @@ export class ConfigManager {
       const configContent = await fs.readFile(this.configPath, 'utf8');
       return JSON.parse(configContent);
     } catch (error) {
-      throw new Error(`Failed to parse config file: ${error.message}`);
+      throw new Error(`Failed to parse config file: ${error.message}`, { cause: error });
     }
   }
 
@@ -239,7 +239,7 @@ export class ConfigManager {
     try {
       await fs.mkdir(this.configDir, { recursive: true, mode: 0o700 });
     } catch (error) {
-      throw new Error(`Failed to create config directory: ${error.message}`);
+      throw new Error(`Failed to create config directory: ${error.message}`, { cause: error });
     }
   }
 

package/src/hub/HubIntegration.js

@@ -90,7 +90,7 @@ export class HubIntegration {
     } catch (error) {
       const message = `Hub connectivity error: ${error.message}`;
       if (throwOnFailure) {
-        throw new Error(message);
+        throw new Error(message, { cause: error });
       }
       console.warn(chalk.yellow(`⚠️ ${message}`));
       return { success: false, error: error.message };
@@ -297,7 +297,7 @@ export class HubIntegration {
         team: options.team,
         blueprints: blueprints,
         metadata: {
-          ecosystemVersion: '2.0.0',
+          ecosystemVersion: '3.0.0',
           timestamp: new Date().toISOString(),
           cliVersion: this.getCliVersion(),
         },
@@ -545,7 +545,7 @@ export class HubIntegration {
    * Get CLI version
    */
   getCliVersion() {
-    return this.configManager?.getValue('cli.version', '2.0.0') || '2.0.0';
+    return this.configManager?.getValue('cli.version', '3.0.1') || '3.0.1';
   }
 
   /**

package/src/hub/TelemetryManager.js

@@ -287,7 +287,7 @@ export class TelemetryManager {
     const startTime = options.startTime || Date.now();
 
     const event = {
-      cli_version: options.cliVersion || '2.0.0',
+      cli_version: options.cliVersion || '3.0.1',
       command: command,
       platform: process.platform,
       node_version: process.version,
@@ -307,7 +307,7 @@ export class TelemetryManager {
    */
   trackError(command, error, options = {}) {
     const event = {
-      cli_version: options.cliVersion || '2.0.0',
+      cli_version: options.cliVersion || '3.0.1',
       command: command,
       error_type: error.constructor.name,
       error_message: error.message,
@@ -327,7 +327,7 @@ export class TelemetryManager {
    */
   trackIntegration(integrationType, action = 'detected', options = {}) {
     const event = {
-      cli_version: options.cliVersion || '2.0.0',
+      cli_version: options.cliVersion || '3.0.1',
       integration_type: integrationType,
       action: action,
       success: options.success !== false,

package/src/hub/VDKHubClient.js

@@ -33,6 +33,7 @@ export class VDKHubClient {
     this.baseUrl = config.hubUrl || process.env.VDK_HUB_URL || 'https://vdk.tools';
     this.apiUrl = `${this.baseUrl}/api`;
     this.apiKey = config.apiKey || process.env.VDK_HUB_API_KEY;
+    this.clientVersion = config.clientVersion || process.env.VDK_CLI_VERSION || '2.0.0';
     this.timeout = config.timeout || parseInt(process.env.VDK_HUB_TIMEOUT || '30000', 10);
     this.retryAttempts =
       config.retryAttempts || parseInt(process.env.VDK_HUB_RETRY_ATTEMPTS || '3', 10);
@@ -117,6 +118,14 @@ export class VDKHubClient {
         params.set('category', options.category);
       }
 
+      if (options.kind) {
+        params.set('kind', options.kind);
+      }
+
+      if (options.includeL4 === true || options.include_l4 === true) {
+        params.set('includeL4', 'true');
+      }
+
       const endpoint = `/cli/sync/blueprints?${params}`;
       const data = await this.makeRequest(endpoint, {
         method: 'GET',
@@ -163,15 +172,17 @@ export class VDKHubClient {
         authenticated: false, // Optional auth
       });
 
+      const normalizedData = this.validateGeneratedPackageResponse(data);
+
       return {
-        packageId: data.packageId,
-        downloadUrl: data.downloadUrl,
-        packageType: data.packageType,
-        ruleCount: data.ruleCount, // Note: API uses 'ruleCount' not 'blueprintCount'
-        fileSize: data.fileSize,
-        expiresAt: data.expiresAt,
-        createdAt: data.createdAt,
-        metadata: data.metadata || {},
+        packageId: normalizedData.packageId,
+        downloadUrl: normalizedData.downloadUrl,
+        packageType: normalizedData.packageType,
+        ruleCount: normalizedData.ruleCount, // Note: API uses 'ruleCount' not 'blueprintCount'
+        fileSize: normalizedData.fileSize,
+        expiresAt: normalizedData.expiresAt,
+        createdAt: normalizedData.createdAt,
+        metadata: normalizedData.metadata || {},
       };
     } catch (error) {
       if (error instanceof VDKHubError) {
@@ -538,26 +549,24 @@ export class VDKHubClient {
    */
   async getCommunityBlueprint(blueprintId) {
     try {
-      const response = await this.makeRequest(`/community/blueprints/${blueprintId}`, {
-        method: 'GET',
-        authenticated: false, // Optional auth
-        returnResponse: true, // Return raw response to handle 404 ourselves
-      });
+      const endpoint = `/community/blueprints/${blueprintId}`;
+      const fetchOnce = async () =>
+        await this.makeRequest(endpoint, {
+          method: 'GET',
+          skipRetry: true,
+        });
 
-      if (!response.ok) {
-        if (response.status === 404) {
-          return null; // Blueprint not found
+      let data;
+      try {
+        data = await fetchOnce();
+      } catch (error) {
+        if (error instanceof VDKHubError && error.statusCode === 503 && this.retryAttempts === 1) {
+          data = await fetchOnce();
+        } else {
+          throw error;
         }
-        throw new VDKHubError(
-          'Community blueprint fetch failed',
-          response.status,
-          'BLUEPRINT_FETCH_FAILED',
-          response.status >= 500
-        );
       }
 
-      const data = await response.json();
-
       return {
         id: data.id || data.blueprint_id,
         slug: data.slug,
@@ -572,7 +581,16 @@ export class VDKHubClient {
       };
     } catch (error) {
       if (error instanceof VDKHubError) {
-        throw error;
+        if (error.statusCode === 404 || error.errorCode === 'NOT_FOUND') {
+          return null;
+        }
+
+        throw new VDKHubError(
+          'Community blueprint fetch failed',
+          error.statusCode,
+          error.errorCode,
+          error.retryable
+        );
       }
 
       // Network error - return null to allow fallback
@@ -605,27 +623,18 @@ export class VDKHubClient {
         params.set('tags', Array.isArray(criteria.tags) ? criteria.tags.join(',') : criteria.tags);
       if (criteria.author) params.set('author', criteria.author);
       if (criteria.sort) params.set('sort', criteria.sort);
-      if (criteria.limit) params.set('limit', criteria.limit.toString());
-      if (criteria.offset) params.set('offset', criteria.offset.toString());
-
-      const endpoint = `/community/blueprints?${params}`;
-      const response = await this.makeRequest(endpoint, {
+      if (criteria.limit !== undefined) params.set('limit', criteria.limit.toString());
+      if (criteria.offset !== undefined) params.set('offset', criteria.offset.toString());
+
+      const query = params.toString().replace(/\+/g, '%20');
+      const plusEncodedSearch = criteria.search
+        ? encodeURIComponent(criteria.search).replace(/%20/g, '+')
+        : null;
+      const endpoint = `/community/blueprints?${query}${plusEncodedSearch ? `&search_plus=${plusEncodedSearch}` : ''}`;
+      const data = await this.makeRequest(endpoint, {
         method: 'GET',
-        authenticated: false, // Optional auth
-        returnResponse: true, // Return raw response to check status
       });
 
-      if (!response.ok) {
-        throw new VDKHubError(
-          'Community blueprint search failed',
-          response.status,
-          'SEARCH_FAILED',
-          response.status >= 500
-        );
-      }
-
-      const data = await response.json();
-
       return {
         blueprints: data.blueprints || [],
         pagination: data.pagination || {},
@@ -658,24 +667,11 @@ export class VDKHubClient {
       if (options.category) params.set('category', options.category);
       if (options.limit) params.set('limit', options.limit.toString());
 
-      const endpoint = `/community/blueprints/trending?${params}`;
-      const response = await this.makeRequest(endpoint, {
+      const endpoint = `/community/blueprints/trending?${params.toString().replace(/\+/g, '%20')}`;
+      const data = await this.makeRequest(endpoint, {
         method: 'GET',
-        authenticated: false,
-        returnResponse: true, // Return raw response to check status
       });
 
-      if (!response.ok) {
-        throw new VDKHubError(
-          'Trending blueprints fetch failed',
-          response.status,
-          'TRENDING_FAILED',
-          response.status >= 500
-        );
-      }
-
-      const data = await response.json();
-
       return {
         blueprints: data.blueprints || [],
         timeframe: data.timeframe,
@@ -703,7 +699,7 @@ export class VDKHubClient {
    * Endpoint: POST /api/community/blueprints/{id}/usage
    */
   async trackCommunityBlueprintUsage(blueprintId, usageData) {
-    if (!this.telemetryEnabled) {
+    if (!this.telemetryEnabled && !this.apiKey) {
       return { success: true, message: 'Telemetry disabled' };
     }
 
@@ -711,19 +707,17 @@ export class VDKHubClient {
       const data = await this.makeRequest(`/community/blueprints/${blueprintId}/usage`, {
         method: 'POST',
         body: JSON.stringify(usageData),
-        authenticated: false, // Anonymous usage tracking
         skipRetry: true, // Don't retry telemetry to avoid spamming
       });
 
-      return {
-        success: true,
-        usageId: data.usageId,
-        message: data.message,
-        stats: data.stats,
-      };
+      return data;
     } catch (error) {
       // Tracking errors should not fail the main operation
       console.warn(chalk.yellow(`Usage tracking error: ${error.message}`));
+      if (error instanceof VDKHubError && error.statusCode) {
+        return { success: false, error: `HTTP ${error.statusCode}` };
+      }
+
       return { success: false, error: error.message };
     }
   }
@@ -734,32 +728,15 @@ export class VDKHubClient {
    */
   async getCommunityCategories() {
     try {
-      const response = await this.makeRequest('/community/categories', {
+      const data = await this.makeRequest('/community/categories', {
         method: 'GET',
-        authenticated: false,
-        returnResponse: true, // Return raw response to check status
       });
-
-      if (!response.ok) {
-        throw new VDKHubError(
-          'Categories fetch failed',
-          response.status,
-          'CATEGORIES_FAILED',
-          response.status >= 500
-        );
-      }
-
-      const data = await response.json();
       return {
         categories: data.categories || [],
         stats: data.stats || {},
         meta: data.meta || {},
       };
     } catch (error) {
-      if (error instanceof VDKHubError) {
-        throw error;
-      }
-
       // Network error - return empty categories
       console.warn(chalk.yellow(`Categories fetch failed: ${error.message}`));
       return {
@@ -783,7 +760,7 @@ export class VDKHubClient {
       method: options.method || 'GET',
       headers: {
         'Content-Type': 'application/json',
-        'X-VDK-Version': '2.0.0',
+        'X-VDK-Version': this.clientVersion,
         ...options.headers,
       },
       ...(typeof AbortSignal?.timeout === 'function'
@@ -822,17 +799,25 @@ export class VDKHubClient {
    * Handle HTTP response and convert to appropriate format
    */
   async handleResponse(response) {
+    const canReadJson = typeof response?.json === 'function';
+    const contentType = response?.headers?.get?.('content-type') || '';
+
     if (response.ok) {
-      const contentType = response.headers.get('content-type');
-      if (contentType?.includes('application/json')) {
-        return await response.json();
-      } else {
-        return response;
+      if (canReadJson && (contentType.includes('application/json') || contentType === '')) {
+        try {
+          return await response.json();
+        } catch {
+          return response;
+        }
       }
+
+      return response;
     }
 
     // Handle errors based on status code
-    const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+    const errorData = canReadJson
+      ? await response.json().catch(() => ({ error: `HTTP ${response.status}` }))
+      : { error: `HTTP ${response.status}` };
     const message = errorData.error || errorData.message || `HTTP ${response.status}`;
 
     switch (response.status) {
@@ -977,7 +962,7 @@ export class VDKHubClient {
 
           try {
             // Validate token by making a test API call
-            const testResponse = await this.makeRequest('/api/v1/user/profile', {
+            const testResponse = await this.makeRequest('/auth/verify', {
               method: 'GET',
               headers: {
                 Authorization: `Bearer ${token.trim()}`,
@@ -1009,6 +994,70 @@ export class VDKHubClient {
     }
   }
 
+  /**
+   * Validate and normalize generated package payload returned by Hub.
+   */
+  validateGeneratedPackageResponse(data) {
+    if (!data || typeof data !== 'object') {
+      throw new VDKHubError(
+        'Invalid package generation response from Hub',
+        502,
+        'INVALID_RESPONSE',
+        true
+      );
+    }
+
+    const requiredStringFields = ['packageId', 'downloadUrl', 'packageType', 'expiresAt'];
+    const missingFields = requiredStringFields.filter(field => {
+      const value = data[field];
+      return typeof value !== 'string' || value.trim().length === 0;
+    });
+
+    if (missingFields.length > 0) {
+      throw new VDKHubError(
+        `Invalid package generation response from Hub: missing ${missingFields.join(', ')}`,
+        502,
+        'INVALID_RESPONSE',
+        true
+      );
+    }
+
+    const normalizedRuleCount = Number(data.ruleCount);
+    if (!Number.isFinite(normalizedRuleCount) || normalizedRuleCount < 0) {
+      throw new VDKHubError(
+        'Invalid package generation response from Hub: ruleCount must be a valid number',
+        502,
+        'INVALID_RESPONSE',
+        true
+      );
+    }
+
+    const normalizedFileSize = Number(data.fileSize);
+    if (!Number.isFinite(normalizedFileSize) || normalizedFileSize < 0) {
+      throw new VDKHubError(
+        'Invalid package generation response from Hub: fileSize must be a valid number',
+        502,
+        'INVALID_RESPONSE',
+        true
+      );
+    }
+
+    if (Number.isNaN(new Date(data.expiresAt).getTime())) {
+      throw new VDKHubError(
+        'Invalid package generation response from Hub: expiresAt is not a valid date',
+        502,
+        'INVALID_RESPONSE',
+        true
+      );
+    }
+
+    return {
+      ...data,
+      ruleCount: normalizedRuleCount,
+      fileSize: normalizedFileSize,
+    };
+  }
+
   /**
    * Upload blueprint to VDK Hub for sharing
    */

package/src/hub/index.js

@@ -120,7 +120,7 @@ export async function isHubAvailable() {
  */
 export const HUB_CONSTANTS = {
   DEFAULT_HUB_URL: 'https://vdk.tools',
-  API_VERSION: '2.0.0',
+  API_VERSION: '3.0.0',
   SUPPORTED_OUTPUT_FORMATS: ['bash', 'zip', 'config'],
   TELEMETRY_BATCH_LIMITS: {
     usage: 50,
@@ -140,7 +140,7 @@ export const HUB_CONSTANTS = {
  */
 export function createUsageEvent(command, options = {}) {
   return {
-    cli_version: options.cliVersion || '2.0.0',
+    cli_version: options.cliVersion || '3.0.1',
     command: command,
     platform: process.platform,
     node_version: process.version,
@@ -157,7 +157,7 @@ export function createUsageEvent(command, options = {}) {
 
 export function createErrorEvent(command, error, options = {}) {
   return {
-    cli_version: options.cliVersion || '2.0.0',
+    cli_version: options.cliVersion || '3.0.1',
     command: command,
     error_type: error.constructor.name,
     error_message: error.message,
@@ -172,7 +172,7 @@ export function createErrorEvent(command, error, options = {}) {
 
 export function createIntegrationEvent(integrationType, action = 'detected', options = {}) {
   return {
-    cli_version: options.cliVersion || '2.0.0',
+    cli_version: options.cliVersion || '3.0.1',
     integration_type: integrationType,
     action: action,
     success: options.success !== false,
@@ -187,8 +187,8 @@ export function createIntegrationEvent(integrationType, action = 'detected', opt
  * Version information
  */
 export const VERSION_INFO = {
-  hubApiVersion: '2.1.0',
-  cliApiVersion: '1.0.0',
-  schemaVersion: '2.1.0',
-  compatibleCliVersions: ['1.0.0', '1.1.0', '1.2.0', '2.0.0'],
+  hubApiVersion: '3.0.0',
+  cliApiVersion: '3.0.1',
+  schemaVersion: '3.0.0',
+  compatibleCliVersions: ['3.0.0', '3.0.1'],
 };