prpm 0.0.10 → 0.0.12

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/core/user-config.js

@@ -1,58 +1,124 @@
 "use strict";
 /**
- * User configuration management for ~/.prpmrc
+ * User configuration management for ~/.prpmrc and .prpmrc
  * Stores global settings like registry URL and authentication token
+ * Supports both user-level (~/.prpmrc) and repository-level (.prpmrc) config
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfig = getConfig;
 exports.saveConfig = saveConfig;
+exports.saveRepoConfig = saveRepoConfig;
+exports.getRepoConfig = getRepoConfig;
+exports.getUserConfig = getUserConfig;
 exports.updateConfig = updateConfig;
 exports.clearAuth = clearAuth;
 exports.getRegistryUrl = getRegistryUrl;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
-const CONFIG_FILE = (0, path_1.join)((0, os_1.homedir)(), '.prpmrc');
+const USER_CONFIG_FILE = (0, path_1.join)((0, os_1.homedir)(), '.prpmrc');
+const REPO_CONFIG_FILE = '.prpmrc';
 const DEFAULT_REGISTRY_URL = 'https://registry.prpm.dev';
 /**
- * Get user configuration
+ * Load configuration from a file
  */
-async function getConfig() {
+async function loadConfigFile(filePath) {
     try {
-        const data = await fs_1.promises.readFile(CONFIG_FILE, 'utf-8');
-        const config = JSON.parse(data);
-        // Allow environment variable to override registry URL
-        if (process.env.PRPM_REGISTRY_URL) {
-            config.registryUrl = process.env.PRPM_REGISTRY_URL;
-        }
-        else if (!config.registryUrl) {
-            config.registryUrl = DEFAULT_REGISTRY_URL;
-        }
-        return config;
+        const data = await fs_1.promises.readFile(filePath, 'utf-8');
+        return JSON.parse(data);
     }
     catch (error) {
-        // If file doesn't exist, return default config
         if (error.code === 'ENOENT') {
-            return {
-                registryUrl: process.env.PRPM_REGISTRY_URL || DEFAULT_REGISTRY_URL,
-                telemetryEnabled: true,
-            };
+            return null;
         }
-        throw new Error(`Failed to read user config: ${error}`);
+        throw new Error(`Failed to read config from ${filePath}: ${error}`);
+    }
+}
+/**
+ * Get merged configuration from user and repository levels
+ * Priority: CLI flags > environment > repo config > user config > defaults
+ */
+async function getConfig() {
+    // Load user-level config (~/.prpmrc)
+    const userConfig = await loadConfigFile(USER_CONFIG_FILE);
+    // Load repository-level config (./prpmrc)
+    const repoConfigPath = (0, path_1.join)(process.cwd(), REPO_CONFIG_FILE);
+    const repoConfig = await loadConfigFile(repoConfigPath);
+    // Merge configs (repo overrides user)
+    const config = {
+        ...userConfig,
+        ...repoConfig,
+    };
+    // Deep merge nested objects
+    if (userConfig?.cursor || repoConfig?.cursor) {
+        config.cursor = {
+            ...userConfig?.cursor,
+            ...repoConfig?.cursor,
+        };
+    }
+    if (userConfig?.claude || repoConfig?.claude) {
+        config.claude = {
+            ...userConfig?.claude,
+            ...repoConfig?.claude,
+        };
+    }
+    if (userConfig?.collections || repoConfig?.collections) {
+        config.collections = {
+            ...userConfig?.collections,
+            ...repoConfig?.collections,
+        };
+    }
+    // Allow environment variable to override registry URL
+    if (process.env.PRPM_REGISTRY_URL) {
+        config.registryUrl = process.env.PRPM_REGISTRY_URL;
     }
+    else if (!config.registryUrl) {
+        config.registryUrl = DEFAULT_REGISTRY_URL;
+    }
+    // Set defaults
+    if (config.telemetryEnabled === undefined) {
+        config.telemetryEnabled = true;
+    }
+    return config;
 }
 /**
- * Save user configuration
+ * Save user configuration to ~/.prpmrc
  */
 async function saveConfig(config) {
     try {
         const data = JSON.stringify(config, null, 2);
-        await fs_1.promises.writeFile(CONFIG_FILE, data, 'utf-8');
+        await fs_1.promises.writeFile(USER_CONFIG_FILE, data, 'utf-8');
     }
     catch (error) {
         throw new Error(`Failed to save user config: ${error}`);
     }
 }
+/**
+ * Save repository configuration to ./.prpmrc
+ */
+async function saveRepoConfig(config) {
+    try {
+        const repoConfigPath = (0, path_1.join)(process.cwd(), REPO_CONFIG_FILE);
+        const data = JSON.stringify(config, null, 2);
+        await fs_1.promises.writeFile(repoConfigPath, data, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save repository config: ${error}`);
+    }
+}
+/**
+ * Get repository-level configuration only
+ */
+async function getRepoConfig() {
+    const repoConfigPath = (0, path_1.join)(process.cwd(), REPO_CONFIG_FILE);
+    return await loadConfigFile(repoConfigPath);
+}
+/**
+ * Get user-level configuration only
+ */
+async function getUserConfig() {
+    return await loadConfigFile(USER_CONFIG_FILE);
+}
 /**
  * Update specific config values
  */

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