prpm 0.0.10 → 0.0.11

package/dist/core/filesystem.js

@@ -18,7 +18,7 @@ const path_1 = __importDefault(require("path"));
 /**
  * Get the destination directory for a package based on format and subtype
  */
-function getDestinationDir(format, subtype) {
+function getDestinationDir(format, subtype, name) {
     switch (format) {
         case 'cursor':
             if (subtype === 'agent')
@@ -28,7 +28,7 @@ function getDestinationDir(format, subtype) {
             return '.cursor/rules';
         case 'claude':
             if (subtype === 'skill')
-                return '.claude/skills';
+                return `.claude/skills/${name}`;
             if (subtype === 'slash-command')
                 return '.claude/commands';
             if (subtype === 'agent')

package/dist/core/marketplace-converter.js

@@ -42,7 +42,8 @@ function marketplaceToManifest(marketplace, pluginIndex = 0) {
     }
     // Generate package name from plugin name
     // Format: @owner/plugin-name
-    const packageName = generatePackageName(marketplace.owner, plugin.name);
+    const ownerName = typeof marketplace.owner === 'string' ? marketplace.owner : marketplace.owner.name;
+    const packageName = generatePackageName(ownerName, plugin.name);
     // Collect all files that should be included
     const files = collectFiles(plugin);
     // Determine the main file
@@ -54,13 +55,25 @@ function marketplaceToManifest(marketplace, pluginIndex = 0) {
     ].slice(0, 20); // Max 20 keywords
     // Extract tags from keywords (first 10)
     const tags = keywords.slice(0, 10);
+    // Get description from plugin, metadata, or root
+    const description = plugin.description ||
+        marketplace.metadata?.description ||
+        marketplace.description ||
+        '';
+    // Get version from plugin, metadata, or root
+    const version = plugin.version ||
+        marketplace.metadata?.version ||
+        marketplace.version ||
+        '1.0.0';
+    // Get author - prefer plugin.author, fallback to owner name
+    const author = plugin.author || ownerName;
     const manifest = {
         name: packageName,
-        version: plugin.version || marketplace.version || '1.0.0',
-        description: plugin.description || marketplace.description,
+        version,
+        description,
         format,
         subtype,
-        author: plugin.author || marketplace.owner,
+        author,
         files,
         tags,
         keywords,
@@ -126,7 +139,7 @@ function collectFiles(plugin) {
         }
     }
     // Add standard files if they're not already included
-    const standardFiles = ['README.md', 'LICENSE', '.claude/marketplace.json'];
+    const standardFiles = ['README.md', 'LICENSE', '.claude/marketplace.json', '.claude-plugin/marketplace.json'];
     for (const file of standardFiles) {
         files.add(file);
     }
@@ -185,10 +198,18 @@ function validateMarketplaceJson(data) {
     if (!marketplace.name || typeof marketplace.name !== 'string') {
         return false;
     }
-    if (!marketplace.owner || typeof marketplace.owner !== 'string') {
+    // owner can be either string or object with name property
+    if (!marketplace.owner) {
         return false;
     }
-    if (!marketplace.description || typeof marketplace.description !== 'string') {
+    if (typeof marketplace.owner !== 'string' &&
+        (typeof marketplace.owner !== 'object' || !marketplace.owner.name)) {
+        return false;
+    }
+    // description can be at root or in metadata
+    const hasDescription = (marketplace.description && typeof marketplace.description === 'string') ||
+        (marketplace.metadata?.description && typeof marketplace.metadata.description === 'string');
+    if (!hasDescription) {
         return false;
     }
     if (!Array.isArray(marketplace.plugins) || marketplace.plugins.length === 0) {

package/dist/core/registry-client.js

@@ -115,13 +115,17 @@ class RegistryClient {
     /**
      * Publish a package (requires authentication)
      */
-    async publish(manifest, tarball) {
+    async publish(manifest, tarball, options) {
         if (!this.token) {
             throw new Error('Authentication required. Run `prpm login` first.');
         }
         const formData = new FormData();
         formData.append('manifest', JSON.stringify(manifest));
         formData.append('tarball', new Blob([tarball]), 'package.tar.gz');
+        // Add org_id if provided
+        if (options?.orgId) {
+            formData.append('org_id', options.orgId);
+        }
         const response = await this.fetch('/api/v1/packages', {
             method: 'POST',
             body: formData,
@@ -205,6 +209,12 @@ class RegistryClient {
      */
     async fetch(path, options = {}, retries = 3) {
         const url = `${this.baseUrl}${path}`;
+        // Debug logging
+        if (process.env.DEBUG || process.env.PRPM_DEBUG) {
+            console.error(`[DEBUG] Fetching: ${url}`);
+            console.error(`[DEBUG] Method: ${options.method || 'GET'}`);
+            console.error(`[DEBUG] Has token: ${!!this.token}`);
+        }
         const headers = {
             'Content-Type': 'application/json',
             ...options.headers,
@@ -215,6 +225,9 @@ class RegistryClient {
         let lastError = null;
         for (let attempt = 0; attempt < retries; attempt++) {
             try {
+                if (process.env.DEBUG || process.env.PRPM_DEBUG) {
+                    console.error(`[DEBUG] Attempt ${attempt + 1}/${retries}`);
+                }
                 const response = await fetch(url, {
                     ...options,
                     headers,
@@ -242,21 +255,35 @@ class RegistryClient {
             }
             catch (error) {
                 lastError = error instanceof Error ? error : new Error(String(error));
+                if (process.env.DEBUG || process.env.PRPM_DEBUG) {
+                    console.error(`[DEBUG] Error on attempt ${attempt + 1}:`, lastError.message);
+                    console.error(`[DEBUG] Error type:`, lastError.constructor.name);
+                    console.error(`[DEBUG] Full error:`, lastError);
+                }
                 // Network errors - retry with exponential backoff
                 if (attempt < retries - 1 && (lastError.message.includes('fetch failed') ||
                     lastError.message.includes('ECONNREFUSED') ||
                     lastError.message.includes('ETIMEDOUT'))) {
                     const waitTime = Math.pow(2, attempt) * 1000;
+                    if (process.env.DEBUG || process.env.PRPM_DEBUG) {
+                        console.error(`[DEBUG] Retrying after ${waitTime}ms...`);
+                    }
                     await new Promise(resolve => setTimeout(resolve, waitTime));
                     continue;
                 }
-                // If it's not a retryable error or we're out of retries, throw
+                // If it's not a retryable error or we're out of retries, throw with more context
                 if (attempt === retries - 1) {
-                    throw lastError;
+                    const enhancedError = new Error(`Failed to connect to registry at ${url}\n` +
+                        `Original error: ${lastError.message}\n\n` +
+                        `💡 Possible causes:\n` +
+                        `   - Registry server is not running\n` +
+                        `   - Network connection issue\n` +
+                        `   - Incorrect PRPM_REGISTRY_URL (currently: ${this.baseUrl})`);
+                    throw enhancedError;
                 }
             }
         }
-        throw lastError || new Error('Request failed after retries');
+        throw lastError || new Error(`Request failed after ${retries} retries to ${url}`);
     }
 }
 exports.RegistryClient = RegistryClient;

package/dist/types/registry.js

@@ -3,3 +3,10 @@
  * Registry API types for CLI
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMultiPackageManifest = isMultiPackageManifest;
+/**
+ * Type guard to check if manifest is multi-package
+ */
+function isMultiPackageManifest(manifest) {
+    return 'packages' in manifest && Array.isArray(manifest.packages);
+}

package/dist/types.js

@@ -3,3 +3,33 @@
  * Core types for the Prompt Package Manager
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBTYPES = exports.FORMATS = void 0;
+/**
+ * Available formats as a constant array
+ * Useful for CLI prompts, validation, etc.
+ */
+exports.FORMATS = [
+    'cursor',
+    'claude',
+    'continue',
+    'windsurf',
+    'copilot',
+    'kiro',
+    'agents.md',
+    'generic',
+    'mcp',
+];
+/**
+ * Available subtypes as a constant array
+ * Useful for CLI prompts, validation, etc.
+ */
+exports.SUBTYPES = [
+    'rule',
+    'agent',
+    'skill',
+    'slash-command',
+    'prompt',
+    'collection',
+    'chatmode',
+    'tool',
+];

package/dist/utils/license-extractor.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * License extraction utilities
+ * Extracts license information from LICENSE files for proper attribution
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractLicenseInfo = extractLicenseInfo;
+exports.validateLicenseInfo = validateLicenseInfo;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const fs_1 = require("fs");
+/**
+ * Common license file names to search for
+ */
+const LICENSE_FILE_PATTERNS = [
+    'LICENSE',
+    'LICENSE.md',
+    'LICENSE.txt',
+    'LICENCE',
+    'LICENCE.md',
+    'LICENCE.txt',
+    'LICENSE-MIT',
+    'LICENSE-APACHE',
+    'COPYING',
+    'COPYING.txt',
+];
+/**
+ * License type detection patterns
+ * Ordered by specificity - more specific patterns first
+ */
+const LICENSE_PATTERNS = [
+    { pattern: /MIT License/i, type: 'MIT' },
+    { pattern: /Apache License[\s\S]*Version 2\.0/i, type: 'Apache-2.0' },
+    { pattern: /GNU GENERAL PUBLIC LICENSE[\s\S]*Version 3/i, type: 'GPL-3.0' },
+    { pattern: /GNU GENERAL PUBLIC LICENSE[\s\S]*Version 2/i, type: 'GPL-2.0' },
+    { pattern: /GNU LESSER GENERAL PUBLIC LICENSE[\s\S]*Version 3/i, type: 'LGPL-3.0' },
+    { pattern: /GNU LESSER GENERAL PUBLIC LICENSE[\s\S]*Version 2/i, type: 'LGPL-2.1' },
+    { pattern: /BSD 3-Clause License/i, type: 'BSD-3-Clause' },
+    { pattern: /BSD 2-Clause License/i, type: 'BSD-2-Clause' },
+    { pattern: /Mozilla Public License[\s\S]*Version 2\.0/i, type: 'MPL-2.0' },
+    { pattern: /ISC License/i, type: 'ISC' },
+    { pattern: /The Unlicense/i, type: 'Unlicense' },
+    { pattern: /Creative Commons Zero[\s\S]*1\.0/i, type: 'CC0-1.0' },
+];
+/**
+ * Detect license type from license text
+ */
+function detectLicenseType(text) {
+    for (const { pattern, type } of LICENSE_PATTERNS) {
+        if (pattern.test(text)) {
+            return type;
+        }
+    }
+    return null;
+}
+/**
+ * Generate GitHub raw URL for license file
+ */
+function generateLicenseUrl(repositoryUrl, fileName) {
+    if (!repositoryUrl) {
+        return null;
+    }
+    // Extract owner/repo from GitHub URL
+    const githubMatch = repositoryUrl.match(/github\.com[/:]([\w-]+)\/([\w-]+)/);
+    if (!githubMatch) {
+        return null;
+    }
+    const [, owner, repo] = githubMatch;
+    // Use raw.githubusercontent.com for direct file access
+    return `https://raw.githubusercontent.com/${owner}/${repo}/main/${fileName}`;
+}
+/**
+ * Find and extract license information from the current directory
+ */
+async function extractLicenseInfo(repositoryUrl) {
+    const cwd = process.cwd();
+    // Try each license file pattern
+    for (const fileName of LICENSE_FILE_PATTERNS) {
+        const filePath = (0, path_1.join)(cwd, fileName);
+        try {
+            // Check if file exists
+            await (0, promises_1.access)(filePath, fs_1.constants.R_OK);
+            // Read license file
+            const text = await (0, promises_1.readFile)(filePath, 'utf-8');
+            // Detect license type
+            const type = detectLicenseType(text);
+            // Generate license URL if repository is provided
+            const url = generateLicenseUrl(repositoryUrl, fileName);
+            return {
+                type,
+                text,
+                url,
+                fileName,
+            };
+        }
+        catch {
+            // File doesn't exist or can't be read, try next pattern
+            continue;
+        }
+    }
+    // No license file found
+    return {
+        type: null,
+        text: null,
+        url: null,
+        fileName: null,
+    };
+}
+/**
+ * Display license information if found
+ */
+function validateLicenseInfo(licenseInfo, packageName) {
+    if (licenseInfo.text && licenseInfo.type) {
+        console.log(`   License: ${licenseInfo.type} (${licenseInfo.fileName})`);
+    }
+    else if (licenseInfo.text && !licenseInfo.type) {
+        console.log(`   License: Found (${licenseInfo.fileName})`);
+    }
+    else {
+        console.log(`   License: Not found (package will be published without license)`);
+    }
+}

package/dist/utils/multi-package.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Multi-package manifest utilities
+ * Handles merging root-level fields with package-level fields
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePackageFields = mergePackageFields;
+exports.getPackagesWithInheritance = getPackagesWithInheritance;
+exports.validateMultiPackageManifest = validateMultiPackageManifest;
+exports.filterPackages = filterPackages;
+/**
+ * Fields that can be inherited from root to packages
+ */
+const INHERITABLE_FIELDS = [
+    'author',
+    'license',
+    'repository',
+    'homepage',
+    'documentation',
+    'organization',
+    'keywords',
+    'tags',
+];
+/**
+ * Merge root-level fields into a package manifest
+ * Package-level fields take precedence over root-level fields
+ */
+function mergePackageFields(root, pkg) {
+    const merged = { ...pkg };
+    // Inherit each inheritable field if not defined in package
+    for (const field of INHERITABLE_FIELDS) {
+        if (merged[field] === undefined && root[field] !== undefined) {
+            // @ts-ignore - dynamic field access
+            merged[field] = root[field];
+        }
+    }
+    return merged;
+}
+/**
+ * Get all packages from a multi-package manifest with inherited fields
+ */
+function getPackagesWithInheritance(manifest) {
+    return manifest.packages.map(pkg => mergePackageFields(manifest, pkg));
+}
+/**
+ * Validate multi-package manifest
+ */
+function validateMultiPackageManifest(manifest) {
+    const errors = [];
+    // Check packages array exists and is not empty
+    if (!manifest.packages || !Array.isArray(manifest.packages)) {
+        errors.push('packages field must be an array');
+        return { valid: false, errors };
+    }
+    if (manifest.packages.length === 0) {
+        errors.push('packages array must contain at least one package');
+        return { valid: false, errors };
+    }
+    // Check for duplicate package names
+    const names = new Set();
+    for (let i = 0; i < manifest.packages.length; i++) {
+        const pkg = manifest.packages[i];
+        if (names.has(pkg.name)) {
+            errors.push(`Duplicate package name: ${pkg.name}`);
+        }
+        names.add(pkg.name);
+    }
+    // Validate each package has required fields
+    for (let i = 0; i < manifest.packages.length; i++) {
+        const pkg = manifest.packages[i];
+        const pkgPrefix = `Package ${i} (${pkg.name || 'unnamed'})`;
+        if (!pkg.name) {
+            errors.push(`${pkgPrefix}: missing required field 'name'`);
+        }
+        if (!pkg.version) {
+            errors.push(`${pkgPrefix}: missing required field 'version'`);
+        }
+        if (!pkg.description) {
+            errors.push(`${pkgPrefix}: missing required field 'description'`);
+        }
+        if (!pkg.format) {
+            errors.push(`${pkgPrefix}: missing required field 'format'`);
+        }
+        if (!pkg.files || pkg.files.length === 0) {
+            errors.push(`${pkgPrefix}: must have at least one file in 'files' array`);
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Filter packages by name or pattern
+ */
+function filterPackages(packages, filter) {
+    // If filter is a number, treat as index
+    if (typeof filter === 'number') {
+        if (filter < 0 || filter >= packages.length) {
+            throw new Error(`Package index ${filter} out of range (0-${packages.length - 1})`);
+        }
+        return [packages[filter]];
+    }
+    // If exact match, return that package
+    const exactMatch = packages.find(pkg => pkg.name === filter);
+    if (exactMatch) {
+        return [exactMatch];
+    }
+    // Try as glob pattern
+    const pattern = filter.replace(/\*/g, '.*');
+    const regex = new RegExp(`^${pattern}$`);
+    const matches = packages.filter(pkg => regex.test(pkg.name));
+    if (matches.length === 0) {
+        throw new Error(`No packages match filter: ${filter}`);
+    }
+    return matches;
+}

package/dist/utils/parallel-publisher.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Parallel publishing utilities with concurrency control
+ * Optimizes multi-package publishing performance
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publishInParallel = publishInParallel;
+exports.withRetry = withRetry;
+exports.formatDuration = formatDuration;
+exports.calculateStats = calculateStats;
+/**
+ * Execute tasks in parallel with concurrency limit
+ */
+async function publishInParallel(tasks, options = {}) {
+    const { concurrency = 5, continueOnError = false, onProgress, onSuccess, onError, } = options;
+    const results = new Array(tasks.length);
+    let completed = 0;
+    let hasError = false;
+    let taskIndex = 0;
+    async function executeTask(task, index) {
+        const startTime = Date.now();
+        try {
+            const result = await task.execute();
+            const duration = Date.now() - startTime;
+            results[index] = {
+                success: true,
+                name: task.name,
+                result,
+                duration,
+            };
+            completed++;
+            onProgress?.(completed, tasks.length, task.name);
+            onSuccess?.(task.name, result);
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const err = error instanceof Error ? error : new Error(String(error));
+            results[index] = {
+                success: false,
+                name: task.name,
+                error: err,
+                duration,
+            };
+            completed++;
+            hasError = true;
+            onProgress?.(completed, tasks.length, task.name);
+            onError?.(task.name, err);
+            // If not continuing on error, mark hasError to skip remaining tasks
+            if (!continueOnError) {
+                throw err;
+            }
+        }
+    }
+    // Execute tasks with concurrency control
+    const executing = new Set();
+    while (taskIndex < tasks.length || executing.size > 0) {
+        // Fill up to concurrency limit
+        while (taskIndex < tasks.length && executing.size < concurrency) {
+            // If in strict mode and we've encountered an error, skip remaining tasks
+            if (!continueOnError && hasError) {
+                results[taskIndex] = {
+                    success: false,
+                    name: tasks[taskIndex].name,
+                    error: new Error('Skipped due to previous failure'),
+                    duration: 0,
+                };
+                taskIndex++;
+                continue;
+            }
+            const currentIndex = taskIndex;
+            const currentTask = tasks[taskIndex];
+            taskIndex++;
+            const promise = executeTask(currentTask, currentIndex)
+                .catch(() => {
+                // Errors already handled in executeTask
+            })
+                .finally(() => {
+                executing.delete(promise);
+            });
+            executing.add(promise);
+        }
+        // Wait for at least one task to complete
+        if (executing.size > 0) {
+            await Promise.race(executing);
+        }
+    }
+    return results;
+}
+/**
+ * Retry a task with exponential backoff
+ */
+async function withRetry(fn, options = {}) {
+    const { maxRetries = 3, initialDelay = 1000, maxDelay = 10000, backoffFactor = 2, } = options;
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Don't retry on last attempt
+            if (attempt === maxRetries - 1) {
+                break;
+            }
+            // Calculate delay with exponential backoff
+            const delay = Math.min(initialDelay * Math.pow(backoffFactor, attempt), maxDelay);
+            await sleep(delay);
+        }
+    }
+    throw lastError || new Error('Max retries exceeded');
+}
+/**
+ * Sleep utility
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Format duration in human-readable format
+ */
+function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    const seconds = (ms / 1000).toFixed(1);
+    return `${seconds}s`;
+}
+function calculateStats(results) {
+    const succeeded = results.filter(r => r.success && r.result !== undefined).length;
+    const failed = results.filter(r => !r.success && r.error && r.error.message !== 'Skipped due to previous failure').length;
+    const skipped = results.filter(r => r.error?.message === 'Skipped due to previous failure').length;
+    const totalDuration = results.reduce((sum, r) => sum + r.duration, 0);
+    const completedCount = succeeded + failed;
+    const avgDuration = completedCount > 0 ? totalDuration / completedCount : 0;
+    return {
+        total: results.length,
+        succeeded,
+        failed,
+        skipped,
+        totalDuration,
+        avgDuration,
+        successRate: results.length > 0 ? succeeded / results.length : 0,
+    };
+}

package/dist/utils/snippet-extractor.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Snippet extraction utilities
+ * Extracts preview content from package files for display in modals
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractSnippet = extractSnippet;
+exports.validateSnippet = validateSnippet;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const MAX_SNIPPET_LENGTH = 2000;
+/**
+ * Extract a preview snippet from package files
+ * Takes the first file in the package and extracts ~2000 characters
+ */
+async function extractSnippet(manifest) {
+    const cwd = process.cwd();
+    try {
+        // Get the first file from the manifest
+        const firstFile = manifest.files[0];
+        if (!firstFile) {
+            return null;
+        }
+        // Get file path (handle both string and object formats)
+        const filePath = typeof firstFile === 'string'
+            ? firstFile
+            : firstFile.path;
+        // If there's a main file specified, prefer that
+        const targetFile = manifest.main || filePath;
+        const fullPath = (0, path_1.join)(cwd, targetFile);
+        // Check if path is a directory
+        const stats = await (0, promises_1.stat)(fullPath);
+        if (stats.isDirectory()) {
+            console.warn(`⚠️  Skipping snippet extraction: "${targetFile}" is a directory`);
+            return null;
+        }
+        // Read the file content
+        const content = await (0, promises_1.readFile)(fullPath, 'utf-8');
+        // Extract first N characters, trying to break at a reasonable point
+        if (content.length <= MAX_SNIPPET_LENGTH) {
+            return content.trim();
+        }
+        // Try to break at a newline near the limit
+        let snippet = content.substring(0, MAX_SNIPPET_LENGTH);
+        const lastNewline = snippet.lastIndexOf('\n');
+        if (lastNewline > MAX_SNIPPET_LENGTH * 0.8) {
+            // If we found a newline in the last 20%, break there
+            snippet = snippet.substring(0, lastNewline);
+        }
+        return snippet.trim() + '\n\n[... content truncated ...]';
+    }
+    catch (error) {
+        // If we can't read the file, return null (snippet is optional)
+        console.warn('⚠️  Could not extract snippet:', error instanceof Error ? error.message : 'Unknown error');
+        return null;
+    }
+}
+/**
+ * Validate snippet and warn if issues found
+ */
+function validateSnippet(snippet, packageName) {
+    if (!snippet) {
+        console.warn(`⚠️  Warning: No content snippet extracted for package "${packageName}"`);
+        console.warn('   A preview snippet helps users see what the prompt contains before installing.');
+        console.warn('');
+    }
+    else {
+        console.log(`   Snippet: ${snippet.length} characters extracted`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Prompt Package Manager CLI - Install and manage prompt-based files",
   "main": "dist/index.js",
   "bin": {
@@ -45,8 +45,8 @@
   "license": "MIT",
   "dependencies": {
     "@octokit/rest": "^22.0.0",
-    "@pr-pm/registry-client": "^1.2.4",
-    "@pr-pm/types": "^0.1.4",
+    "@pr-pm/registry-client": "^1.2.5",
+    "@pr-pm/types": "^0.1.5",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",