prpm 0.0.6 → 0.0.8

package/dist/commands/install.js

@@ -48,60 +48,69 @@ const lockfile_1 = require("../core/lockfile");
 const cursor_config_1 = require("../core/cursor-config");
 const claude_config_1 = require("../core/claude-config");
 /**
- * Get icon for package type
+ * Get icon for package format and subtype
  */
-function getTypeIcon(type) {
-    const icons = {
-        'claude-skill': '🎓',
-        'claude-agent': '🤖',
-        'claude-slash-command': '⚡',
+function getPackageIcon(format, subtype) {
+    // Subtype icons take precedence
+    const subtypeIcons = {
+        'skill': '🎓',
+        'agent': '🤖',
+        'slash-command': '⚡',
+        'rule': '📋',
+        'prompt': '💬',
+        'workflow': '⚡',
+        'tool': '🔧',
+        'template': '📄',
+        'collection': '📦',
+        'chatmode': '💬',
+    };
+    // Format-specific icons for rules/defaults
+    const formatIcons = {
         'claude': '🤖',
         'cursor': '📋',
-        'cursor-agent': '🤖',
-        'cursor-slash-command': '⚡',
         'windsurf': '🌊',
         'continue': '➡️',
+        'copilot': '✈️',
+        'kiro': '🎯',
         'mcp': '🔗',
+        'agents.md': '📝',
         'generic': '📦',
-        // Legacy mappings
-        skill: '🎓',
-        agent: '🤖',
-        rule: '📋',
-        plugin: '🔌',
-        prompt: '💬',
-        workflow: '⚡',
-        tool: '🔧',
-        template: '📄',
     };
-    return icons[type] || '📦';
+    return subtypeIcons[subtype] || formatIcons[format] || '📦';
 }
 /**
- * Get human-readable label for package type
+ * Get human-readable label for package format and subtype
  */
-function getTypeLabel(type) {
-    const labels = {
-        'claude-skill': 'Claude Skill',
-        'claude-agent': 'Claude Agent',
-        'claude-slash-command': 'Claude Slash Command',
-        'claude': 'Claude Agent',
-        'cursor': 'Cursor Rule',
-        'cursor-agent': 'Cursor Agent',
-        'cursor-slash-command': 'Cursor Slash Command',
-        'windsurf': 'Windsurf Rule',
-        'continue': 'Continue Rule',
-        'mcp': 'MCP Server',
-        'generic': 'Package',
-        // Legacy mappings
-        skill: 'Skill',
-        agent: 'Agent',
-        rule: 'Rule',
-        plugin: 'Plugin',
-        prompt: 'Prompt',
-        workflow: 'Workflow',
-        tool: 'Tool',
-        template: 'Template',
+function getPackageLabel(format, subtype) {
+    const formatLabels = {
+        'claude': 'Claude',
+        'cursor': 'Cursor',
+        'windsurf': 'Windsurf',
+        'continue': 'Continue',
+        'copilot': 'GitHub Copilot',
+        'kiro': 'Kiro',
+        'mcp': 'MCP',
+        'agents.md': 'Agents.md',
+        'generic': '',
+    };
+    const subtypeLabels = {
+        'skill': 'Skill',
+        'agent': 'Agent',
+        'slash-command': 'Slash Command',
+        'rule': 'Rule',
+        'prompt': 'Prompt',
+        'workflow': 'Workflow',
+        'tool': 'Tool',
+        'template': 'Template',
+        'collection': 'Collection',
+        'chatmode': 'Chat Mode',
     };
-    return labels[type] || type;
+    const formatLabel = formatLabels[format];
+    const subtypeLabel = subtypeLabels[subtype];
+    if (format === 'generic') {
+        return subtypeLabel;
+    }
+    return `${formatLabel} ${subtypeLabel}`;
 }
 async function handleInstall(packageSpec, options) {
     const startTime = Date.now();
@@ -151,7 +160,7 @@ async function handleInstall(packageSpec, options) {
             if (!requestedVersion || requestedVersion === 'latest' || requestedVersion === installedPkg.version) {
                 console.log(`\n✨ Package already installed!`);
                 console.log(`   📦 ${packageId}@${installedPkg.version}`);
-                console.log(`   🔄 Format: ${installedPkg.format || installedPkg.type || 'unknown'}`);
+                console.log(`   🔄 Format: ${installedPkg.format || 'unknown'} | Subtype: ${installedPkg.subtype || 'unknown'}`);
                 console.log(`\n💡 To reinstall or upgrade:`);
                 console.log(`   prpm upgrade ${packageId}     # Upgrade to latest version`);
                 console.log(`   prpm uninstall ${packageId}   # Uninstall first, then install`);
@@ -199,13 +208,29 @@ async function handleInstall(packageSpec, options) {
         }
         // Get package info
         const pkg = await client.getPackage(packageId);
-        const typeIcon = getTypeIcon(pkg.type);
-        const typeLabel = getTypeLabel(pkg.type);
+        const typeIcon = getPackageIcon(pkg.format, pkg.subtype);
+        const typeLabel = getPackageLabel(pkg.format, pkg.subtype);
         console.log(`   ${pkg.name} ${pkg.official ? '🏅' : ''}`);
         console.log(`   ${pkg.description || 'No description'}`);
         console.log(`   ${typeIcon} Type: ${typeLabel}`);
-        // Determine format preference - use package type if no explicit conversion requested
-        const format = options.as || pkg.type;
+        // Determine format preference
+        let format = options.as || pkg.format;
+        // Special handling for Claude packages: default to CLAUDE.md if it doesn't exist
+        // BUT only for packages that are generic rules (not skills, agents, or commands)
+        if (!options.as && pkg.format === 'claude' && pkg.subtype === 'rule') {
+            const { fileExists } = await Promise.resolve().then(() => __importStar(require('../core/filesystem.js')));
+            const claudeMdExists = await fileExists('CLAUDE.md');
+            if (!claudeMdExists) {
+                // CLAUDE.md doesn't exist, install as CLAUDE.md (recommended format for Claude Code)
+                format = 'claude-md';
+                console.log(`   💡 Installing as CLAUDE.md (recommended for Claude Code)`);
+                console.log(`      To install as skill instead, use: prpm install ${packageId} --as claude`);
+            }
+            else {
+                // CLAUDE.md already exists, install as skill to avoid overwriting
+                console.log(`   ℹ️  CLAUDE.md already exists, installing as skill in .claude/skills/`);
+            }
+        }
         if (options.as && format !== 'canonical') {
             console.log(`   🔄 Converting to ${format} format...`);
         }
@@ -228,58 +253,36 @@ async function handleInstall(packageSpec, options) {
         const tarball = await client.downloadPackage(tarballUrl, { format });
         // Extract tarball and save files
         console.log(`   📂 Extracting...`);
-        // Determine effective type based on format and original package type
-        let effectiveType;
-        if (format === 'cursor') {
-            // Map package types to cursor equivalents
-            if (pkg.type === 'claude-slash-command' || pkg.type === 'cursor-slash-command') {
-                effectiveType = 'cursor-slash-command';
-            }
-            else if (pkg.type === 'claude-agent' || pkg.type === 'cursor-agent') {
-                effectiveType = 'cursor-agent';
-            }
-            else {
-                effectiveType = 'cursor';
-            }
-        }
-        else if (format === 'claude') {
-            // Map package types to claude equivalents
-            if (pkg.type === 'cursor-slash-command' || pkg.type === 'claude-slash-command') {
-                effectiveType = 'claude-slash-command';
-            }
-            else if (pkg.type === 'cursor-agent' || pkg.type === 'claude-agent') {
-                effectiveType = 'claude-agent';
-            }
-            else if (pkg.type === 'claude-skill') {
-                effectiveType = 'claude-skill';
-            }
-            else {
-                effectiveType = 'claude-agent';
-            }
-        }
-        else if (format === 'continue' || format === 'windsurf') {
-            effectiveType = format;
-        }
-        else {
-            effectiveType = (options.type || pkg.type);
-        }
-        const destDir = (0, filesystem_1.getDestinationDir)(effectiveType);
+        // Determine effective format and subtype (from conversion or package native format)
+        const effectiveFormat = format || pkg.format;
+        const effectiveSubtype = pkg.subtype;
         // Extract all files from tarball
         const extractedFiles = await extractTarball(tarball, packageId);
         // Track where files were saved for user feedback
         let destPath;
         let fileCount = 0;
+        // Special handling for CLAUDE.md format (goes in project root)
+        if (format === 'claude-md') {
+            if (extractedFiles.length !== 1) {
+                throw new Error('CLAUDE.md format only supports single-file packages');
+            }
+            let mainFile = extractedFiles[0].content;
+            destPath = 'CLAUDE.md';
+            await (0, filesystem_1.saveFile)(destPath, mainFile);
+            fileCount = 1;
+        }
         // Check if this is a multi-file package
-        if (extractedFiles.length === 1) {
+        else if (extractedFiles.length === 1) {
+            const destDir = (0, filesystem_1.getDestinationDir)(effectiveFormat, effectiveSubtype);
             // Single file package
             let mainFile = extractedFiles[0].content;
-            // Determine file extension based on effective type
+            // Determine file extension based on effective format
             // Cursor rules use .mdc, but slash commands and other files use .md
-            const fileExtension = (effectiveType === 'cursor' && format === 'cursor') ? 'mdc' : 'md';
+            const fileExtension = (effectiveFormat === 'cursor' && format === 'cursor') ? 'mdc' : 'md';
             const packageName = (0, filesystem_1.stripAuthorNamespace)(packageId);
             destPath = `${destDir}/${packageName}.${fileExtension}`;
             // Handle cursor format - add header if missing for .mdc files
-            if (format === 'cursor' && effectiveType === 'cursor') {
+            if (format === 'cursor' && effectiveFormat === 'cursor') {
                 if (!(0, cursor_config_1.hasMDCHeader)(mainFile)) {
                     console.log(`   ⚠️  Adding missing MDC header...`);
                     mainFile = (0, cursor_config_1.addMDCHeader)(mainFile, pkg.description);
@@ -301,11 +304,34 @@ async function handleInstall(packageSpec, options) {
             fileCount = 1;
         }
         else {
+            const destDir = (0, filesystem_1.getDestinationDir)(effectiveFormat, effectiveSubtype);
             // Multi-file package - create directory for package
             const packageName = (0, filesystem_1.stripAuthorNamespace)(packageId);
             const packageDir = `${destDir}/${packageName}`;
             destPath = packageDir;
             console.log(`   📁 Multi-file package - creating directory: ${packageDir}`);
+            // For Claude skills, auto-fix filename to SKILL.md if needed
+            if (effectiveFormat === 'claude' && effectiveSubtype === 'skill') {
+                const skillMdIndex = extractedFiles.findIndex(f => f.name === 'SKILL.md');
+                if (skillMdIndex === -1) {
+                    // SKILL.md not found, look for common variations and auto-rename
+                    const skillFileIndex = extractedFiles.findIndex(f => f.name.toLowerCase() === 'skill.md' ||
+                        f.name === 'skill.md' ||
+                        f.name.endsWith('.md') && extractedFiles.length === 1 // Single .md file
+                    );
+                    if (skillFileIndex !== -1) {
+                        const oldName = extractedFiles[skillFileIndex].name;
+                        console.log(`   ⚠️  Auto-fixing skill filename: ${oldName} → SKILL.md`);
+                        console.log(`      (Claude skills must be named SKILL.md per official documentation)`);
+                        extractedFiles[skillFileIndex].name = 'SKILL.md';
+                    }
+                    else {
+                        throw new Error('Claude skills must contain a SKILL.md file. ' +
+                            'According to Claude documentation, skills must have a file named SKILL.md in their directory. ' +
+                            'No suitable file found to rename. Please update the package to follow this requirement.');
+                    }
+                }
+            }
             for (const file of extractedFiles) {
                 const filePath = `${packageDir}/${file.name}`;
                 await (0, filesystem_1.saveFile)(filePath, file.content);
@@ -318,8 +344,8 @@ async function handleInstall(packageSpec, options) {
         (0, lockfile_1.addToLockfile)(updatedLockfile, packageId, {
             version: actualVersion || version,
             tarballUrl,
-            type: pkg.type,
-            format,
+            format: pkg.format, // Preserve original package format
+            subtype: pkg.subtype, // Preserve original package subtype
             installedPath: destPath,
         });
         (0, lockfile_1.setPackageIntegrity)(updatedLockfile, packageId, tarball);
@@ -357,7 +383,7 @@ async function handleInstall(packageSpec, options) {
             data: {
                 packageId: packageSpec.split('@')[0],
                 version: options.version || 'latest',
-                type: options.type,
+                convertTo: options.as,
             },
         });
         await telemetry_1.telemetry.shutdown();
@@ -455,23 +481,26 @@ function createInstallCommand() {
         .description('Install a package from the registry')
         .argument('<package>', 'Package to install (e.g., react-rules or react-rules@1.2.0)')
         .option('--version <version>', 'Specific version to install')
-        .option('--type <type>', 'Override package type (cursor, claude, continue)')
-        .option('--as <format>', 'Download in specific format (cursor, claude, continue, windsurf)')
+        .option('--as <format>', 'Convert and install in specific format (cursor, claude, continue, windsurf, canonical)')
+        .option('--format <format>', 'Alias for --as')
         .option('--frozen-lockfile', 'Fail if lock file needs to be updated (for CI)')
         .action(async (packageSpec, options) => {
-        if (options.type && !['cursor', 'claude', 'continue', 'windsurf', 'generic'].includes(options.type)) {
-            console.error('❌ Type must be one of: cursor, claude, continue, windsurf, generic');
-            process.exit(1);
-        }
-        if (options.as && !['cursor', 'claude', 'continue', 'windsurf', 'canonical'].includes(options.as)) {
+        // Support both --as and --format (format is alias for as)
+        const convertTo = options.format || options.as;
+        if (convertTo && !['cursor', 'claude', 'continue', 'windsurf', 'canonical'].includes(convertTo)) {
             console.error('❌ Format must be one of: cursor, claude, continue, windsurf, canonical');
+            console.log('\n💡 Examples:');
+            console.log('   prpm install my-package --as cursor       # Convert to Cursor format');
+            console.log('   prpm install my-package --format claude   # Convert to Claude format');
+            console.log('   prpm install my-package                   # Install in native format');
             process.exit(1);
         }
         await handleInstall(packageSpec, {
-            type: options.type,
-            as: options.as,
+            version: options.version,
+            as: convertTo,
             frozenLockfile: options.frozenLockfile
         });
+        process.exit(0);
     });
     return command;
 }

package/dist/commands/list.js

@@ -92,12 +92,12 @@ async function displayPackages(packages) {
     // Find file locations
     const packagesWithLocations = await Promise.all(packages.map(async (pkg) => ({
         ...pkg,
-        location: await findPackageLocation(pkg.id, pkg.type)
+        location: await findPackageLocation(pkg.id, `${pkg.format}-${pkg.subtype}`)
     })));
     // Calculate column widths
     const idWidth = Math.max(8, ...packagesWithLocations.map(p => p.id.length));
     const versionWidth = Math.max(7, ...packagesWithLocations.map(p => p.version.length));
-    const typeWidth = Math.max(6, ...packagesWithLocations.map(p => (p.type || '').length));
+    const typeWidth = Math.max(6, ...packagesWithLocations.map(p => (`${p.format || ''}-${p.subtype || ''}`).length));
     const locationWidth = Math.max(8, ...packagesWithLocations.map(p => (p.location || 'N/A').length));
     // Header
     const header = [
@@ -113,7 +113,7 @@ async function displayPackages(packages) {
         const row = [
             pkg.id.padEnd(idWidth),
             pkg.version.padEnd(versionWidth),
-            (pkg.type || '').padEnd(typeWidth),
+            (`${pkg.format}-${pkg.subtype}` || '').padEnd(typeWidth),
             (pkg.location || 'N/A').padEnd(locationWidth)
         ].join(' | ');
         console.log(row);
@@ -161,6 +161,9 @@ function createListCommand() {
     const command = new commander_1.Command('list');
     command
         .description('List all installed prompt packages')
-        .action(handleList);
+        .action(async () => {
+        await handleList();
+        process.exit(0);
+    });
     return command;
 }

package/dist/commands/login.js

@@ -140,7 +140,10 @@ async function loginWithOAuth(registryUrl) {
         }
         // Create the CLI auth URL with session token, callback, and userId
         const callbackUrl = 'http://localhost:8765/callback';
-        const webappUrl = registryUrl.replace('registry', 'webapp').replace(':3000', ':5173');
+        // Determine webapp URL - default to production
+        const webappUrl = registryUrl.includes('localhost')
+            ? registryUrl.replace(':3000', ':5173') // Local: localhost:3000 → localhost:5173
+            : 'https://prpm.dev'; // Production: always use prpm.dev
         const authUrl = `${webappUrl}/cli-auth?sessionToken=${encodeURIComponent(connectSessionToken)}&cliCallback=${encodeURIComponent(callbackUrl)}&userId=${encodeURIComponent(userId)}`;
         console.log(`   Please open this link in your browser to authenticate:`);
         console.log(`   ${authUrl}\n`);
@@ -281,5 +284,8 @@ function createLoginCommand() {
     return new commander_1.Command('login')
         .description('Login to the PRMP registry')
         .option('--token <token>', 'Login with a personal access token')
-        .action(handleLogin);
+        .action(async (options) => {
+        await handleLogin(options);
+        process.exit(0);
+    });
 }

package/dist/commands/outdated.js

@@ -124,5 +124,8 @@ function getUpdateType(current, latest) {
 function createOutdatedCommand() {
     return new commander_1.Command('outdated')
         .description('Check for package updates')
-        .action(handleOutdated);
+        .action(async () => {
+        await handleOutdated();
+        process.exit(0);
+    });
 }

package/dist/commands/popular.js

@@ -14,7 +14,10 @@ const trending_1 = require("./trending");
 async function handlePopular(options) {
     // Delegate to trending command
     console.log('📊 Popular Packages (All Time)\n');
-    await (0, trending_1.handleTrending)({ type: options.type });
+    await (0, trending_1.handleTrending)({
+        format: options.format,
+        subtype: options.subtype
+    });
 }
 /**
  * Create the popular command
@@ -22,6 +25,10 @@ async function handlePopular(options) {
 function createPopularCommand() {
     return new commander_1.Command('popular')
         .description('Show popular packages (all time)')
-        .option('-t, --type <type>', 'Filter by package type (cursor, claude, continue, windsurf)')
-        .action(handlePopular);
+        .option('--format <format>', 'Filter by format (cursor, claude, continue, windsurf, copilot, kiro, generic)')
+        .option('--subtype <subtype>', 'Filter by subtype (rule, agent, skill, slash-command, prompt, workflow, tool, template, collection)')
+        .action(async (options) => {
+        await handlePopular(options);
+        process.exit(0);
+    });
 }

package/dist/commands/publish.js

@@ -65,7 +65,13 @@ async function findAndLoadManifest() {
         return { manifest: validated, source: 'prpm.json' };
     }
     catch (error) {
-        // prpm.json not found or invalid, try marketplace.json
+        // If it's a validation error, throw it immediately (don't try marketplace.json)
+        if (error instanceof Error && (error.message.includes('Manifest validation failed') ||
+            error.message.includes('Claude skill') ||
+            error.message.includes('SKILL.md'))) {
+            throw error;
+        }
+        // Otherwise, prpm.json not found or invalid JSON, try marketplace.json
     }
     // Try .claude/marketplace.json (Claude format)
     const marketplaceJsonPath = (0, path_1.join)(process.cwd(), '.claude', 'marketplace.json');
@@ -103,13 +109,55 @@ function validateManifest(manifest) {
     // Check if using enhanced format (file objects)
     const hasEnhancedFormat = manifest.files.some(f => typeof f === 'object');
     if (hasEnhancedFormat) {
-        // Check if files have multiple distinct types
-        const fileTypes = new Set(manifest.files
+        // Check if files have multiple distinct formats
+        const fileFormats = new Set(manifest.files
             .filter(f => typeof f === 'object')
-            .map(f => f.type));
-        // Only suggest "collection" if there are multiple distinct types
-        if (fileTypes.size > 1 && manifest.type !== 'collection') {
-            console.warn('⚠️  Package contains multiple file types. Consider setting type to "collection" for clarity.');
+            .map(f => f.format));
+        // Only suggest "collection" if there are multiple distinct formats
+        if (fileFormats.size > 1 && manifest.subtype !== 'collection') {
+            console.warn('⚠️  Package contains multiple file formats. Consider setting subtype to "collection" for clarity.');
+        }
+    }
+    // Enforce SKILL.md filename for Claude skills
+    if (manifest.format === 'claude' && manifest.subtype === 'skill') {
+        const filePaths = normalizeFilePaths(manifest.files);
+        const hasSkillMd = filePaths.some(path => path.endsWith('/SKILL.md') || path === 'SKILL.md');
+        if (!hasSkillMd) {
+            throw new Error('Claude skills must contain a SKILL.md file.\n' +
+                'According to Claude documentation at https://docs.claude.com/en/docs/claude-code/skills,\n' +
+                'skills must have a file named SKILL.md in their directory.\n' +
+                'Please rename your skill file to SKILL.md (all caps) and update your prpm.json files array.');
+        }
+        // Validate skill name length (max 64 characters)
+        if (manifest.name.length > 64) {
+            throw new Error(`Claude skill name "${manifest.name}" exceeds 64 character limit (${manifest.name.length} characters).\n` +
+                'According to Claude documentation, skill names must be max 64 characters.\n' +
+                'Please shorten your package name.');
+        }
+        // Validate skill name format (lowercase, numbers, hyphens only)
+        if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+            throw new Error(`Claude skill name "${manifest.name}" contains invalid characters.\n` +
+                'According to Claude documentation, skill names must use lowercase letters, numbers, and hyphens only.\n' +
+                'Please update your package name.');
+        }
+        // Validate description length (max 1024 characters)
+        if (manifest.description.length > 1024) {
+            throw new Error(`Claude skill description exceeds 1024 character limit (${manifest.description.length} characters).\n` +
+                'According to Claude documentation, skill descriptions must be max 1024 characters.\n' +
+                'Please shorten your description.');
+        }
+        // Warn if description is approaching the limit (80% = 819 chars)
+        if (manifest.description.length > 819) {
+            console.warn(`⚠️  Warning: Skill description is ${manifest.description.length}/1024 characters (${Math.round(manifest.description.length / 1024 * 100)}% of limit).\n` +
+                '   Consider keeping it concise for better discoverability.');
+        }
+        // Warn if description is too short (less than 100 chars)
+        if (manifest.description.length < 100) {
+            console.warn(`⚠️  Warning: Skill description is only ${manifest.description.length} characters.\n` +
+                '   Claude uses descriptions for skill discovery - consider adding more detail about:\n' +
+                '   - What the skill does\n' +
+                '   - When Claude should use it\n' +
+                '   - What problems it solves');
         }
     }
     return manifest;
@@ -212,14 +260,24 @@ async function handlePublish(options) {
         version = manifest.version;
         console.log(`   Source: ${source}`);
         console.log(`   Package: ${manifest.name}@${manifest.version}`);
-        console.log(`   Type: ${manifest.type}`);
+        console.log(`   Format: ${manifest.format} | Subtype: ${manifest.subtype || 'rule (default)'}`);
         console.log(`   Description: ${manifest.description}`);
         console.log('');
         // Create tarball
         console.log('📦 Creating package tarball...');
         const tarball = await createTarball(manifest);
-        const sizeMB = (tarball.length / (1024 * 1024)).toFixed(2);
-        console.log(`   Size: ${sizeMB}MB`);
+        // Display size in KB or MB depending on size
+        const sizeInBytes = tarball.length;
+        const sizeInKB = sizeInBytes / 1024;
+        const sizeInMB = sizeInBytes / (1024 * 1024);
+        let sizeDisplay;
+        if (sizeInMB >= 1) {
+            sizeDisplay = `${sizeInMB.toFixed(2)}MB`;
+        }
+        else {
+            sizeDisplay = `${sizeInKB.toFixed(2)}KB`;
+        }
+        console.log(`   Size: ${sizeDisplay}`);
         console.log('');
         if (options.dryRun) {
             console.log('✅ Dry run successful! Package is ready to publish.');
@@ -243,6 +301,34 @@ async function handlePublish(options) {
     catch (err) {
         error = err instanceof Error ? err.message : String(err);
         console.error(`\n❌ Failed to publish package: ${error}\n`);
+        // Provide helpful hints based on error type
+        if (error.includes('Manifest validation failed')) {
+            console.log('💡 Common validation issues:');
+            console.log('   - Missing required fields (name, version, description, format)');
+            console.log('   - Invalid format or subtype values');
+            console.log('   - Description too short (min 10 chars) or too long (max 500 chars)');
+            console.log('   - Package name must be lowercase with hyphens only');
+            console.log('');
+            console.log('💡 For Claude skills specifically:');
+            console.log('   - Add "subtype": "skill" to your prpm.json');
+            console.log('   - Ensure files include a SKILL.md file');
+            console.log('   - Package name must be max 64 characters');
+            console.log('');
+            console.log('💡 View the schema: prpm schema');
+            console.log('');
+        }
+        else if (error.includes('SKILL.md')) {
+            console.log('💡 Claude skills require:');
+            console.log('   - A file named SKILL.md (all caps) in your package');
+            console.log('   - "format": "claude" and "subtype": "skill" in prpm.json');
+            console.log('');
+        }
+        else if (error.includes('No manifest file found')) {
+            console.log('💡 Create a manifest file:');
+            console.log('   - Run: prpm init');
+            console.log('   - Or create prpm.json manually');
+            console.log('');
+        }
         process.exit(1);
     }
     finally {
@@ -270,5 +356,8 @@ function createPublishCommand() {
         .option('--access <type>', 'Package access (public or private)', 'public')
         .option('--tag <tag>', 'NPM-style tag (e.g., latest, beta)', 'latest')
         .option('--dry-run', 'Validate package without publishing')
-        .action(handlePublish);
+        .action(async (options) => {
+        await handlePublish(options);
+        process.exit(0);
+    });
 }

package/dist/commands/schema.js

@@ -32,6 +32,9 @@ function createSchemaCommand() {
     const command = new commander_1.Command('schema');
     command
         .description('Display the PRPM manifest JSON schema')
-        .action(handleSchema);
+        .action(async () => {
+        await handleSchema();
+        process.exit(0);
+    });
     return command;
 }