prpm 0.0.9 → 0.0.11

package/dist/commands/uninstall.js

@@ -24,31 +24,69 @@ async function handleUninstall(name) {
         // Get destination directory using format and subtype
         const format = pkg.format || 'generic';
         const subtype = pkg.subtype || 'rule';
-        const destDir = (0, filesystem_1.getDestinationDir)(format, subtype);
-        const fileExtension = pkg.format === 'cursor' ? 'mdc' : 'md';
-        // Strip author namespace to get just the package name
         const packageName = (0, filesystem_1.stripAuthorNamespace)(name);
-        // Try single file first
-        const singleFilePath = `${destDir}/${packageName}.${fileExtension}`;
-        if (await (0, filesystem_1.fileExists)(singleFilePath)) {
-            // Single file package
-            await (0, filesystem_1.deleteFile)(singleFilePath);
-            console.log(`   🗑️  Deleted file: ${singleFilePath}`);
+        const destDir = (0, filesystem_1.getDestinationDir)(format, subtype, packageName);
+        const fileExtension = pkg.format === 'cursor' ? 'mdc' : 'md';
+        // For Claude skills, check the directory structure first (since they use SKILL.md)
+        if (format === 'claude' && subtype === 'skill') {
+            // Claude skills are in .claude/skills/${packageName}/ with SKILL.md file
+            const skillPath = `${destDir}/SKILL.md`;
+            if (await (0, filesystem_1.fileExists)(skillPath)) {
+                // Delete the SKILL.md file
+                await (0, filesystem_1.deleteFile)(skillPath);
+                console.log(`   🗑️  Deleted file: ${skillPath}`);
+                // If the directory is empty or only contains SKILL.md, delete the directory too
+                try {
+                    const dirContents = await fs_1.promises.readdir(destDir);
+                    if (dirContents.length === 0) {
+                        await fs_1.promises.rmdir(destDir);
+                        console.log(`   🗑️  Deleted empty directory: ${destDir}`);
+                    }
+                }
+                catch (error) {
+                    // Directory doesn't exist or can't be deleted, that's okay
+                }
+            }
+            else {
+                // Try the whole directory
+                try {
+                    const stats = await fs_1.promises.stat(destDir);
+                    if (stats.isDirectory()) {
+                        await fs_1.promises.rm(destDir, { recursive: true, force: true });
+                        console.log(`   🗑️  Deleted directory: ${destDir}`);
+                    }
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.code !== 'ENOENT') {
+                        console.warn(`   ⚠️  Could not delete package files: ${err.message}`);
+                    }
+                }
+            }
         }
         else {
-            // Try multi-file package directory
-            const packageDir = `${destDir}/${packageName}`;
-            try {
-                const stats = await fs_1.promises.stat(packageDir);
-                if (stats.isDirectory()) {
-                    await fs_1.promises.rm(packageDir, { recursive: true, force: true });
-                    console.log(`   🗑️  Deleted directory: ${packageDir}`);
-                }
+            // For other formats, try single file first
+            const singleFilePath = `${destDir}/${packageName}.${fileExtension}`;
+            if (await (0, filesystem_1.fileExists)(singleFilePath)) {
+                // Single file package
+                await (0, filesystem_1.deleteFile)(singleFilePath);
+                console.log(`   🗑️  Deleted file: ${singleFilePath}`);
             }
-            catch (error) {
-                const err = error;
-                if (err.code !== 'ENOENT') {
-                    console.warn(`   ⚠️  Could not delete package files: ${err.message}`);
+            else {
+                // Try multi-file package directory
+                const packageDir = `${destDir}/${packageName}`;
+                try {
+                    const stats = await fs_1.promises.stat(packageDir);
+                    if (stats.isDirectory()) {
+                        await fs_1.promises.rm(packageDir, { recursive: true, force: true });
+                        console.log(`   🗑️  Deleted directory: ${packageDir}`);
+                    }
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.code !== 'ENOENT') {
+                        console.warn(`   ⚠️  Could not delete package files: ${err.message}`);
+                    }
                 }
             }
         }

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;
+}