prpm 0.0.10 → 0.0.12

package/dist/commands/publish.js

@@ -49,29 +49,93 @@ const user_config_1 = require("../core/user-config");
 const telemetry_1 = require("../core/telemetry");
 const marketplace_converter_1 = require("../core/marketplace-converter");
 const schema_validator_1 = require("../core/schema-validator");
+const license_extractor_1 = require("../utils/license-extractor");
+const snippet_extractor_1 = require("../utils/snippet-extractor");
 /**
- * Try to find and load a manifest file
+ * Try to find and load manifest files
  * Checks for:
- * 1. prpm.json (native format)
- * 2. .claude/marketplace.json (Claude format)
+ * 1. prpm.json (native format) - returns single manifest or array of packages
+ * 2. .claude/marketplace.json (Claude format) - returns all plugins as separate manifests
+ * 3. .claude-plugin/marketplace.json (Claude format - alternative location) - returns all plugins
  */
-async function findAndLoadManifest() {
+async function findAndLoadManifests() {
     // Try prpm.json first (native format)
     const prpmJsonPath = (0, path_1.join)(process.cwd(), 'prpm.json');
+    let prpmJsonExists = false;
+    let prpmJsonError = null;
     try {
         const content = await (0, promises_1.readFile)(prpmJsonPath, 'utf-8');
-        const manifest = JSON.parse(content);
+        prpmJsonExists = true;
+        // Try to parse JSON
+        let manifest;
+        try {
+            manifest = JSON.parse(content);
+        }
+        catch (parseError) {
+            // JSON parse error - provide specific error message
+            const error = parseError;
+            throw new Error(`Invalid JSON in prpm.json:\n\n` +
+                `${error.message}\n\n` +
+                `Please check your prpm.json file for syntax errors:\n` +
+                `  - Missing or extra commas\n` +
+                `  - Unclosed quotes or brackets\n` +
+                `  - Invalid JSON syntax\n\n` +
+                `You can validate your JSON at https://jsonlint.com/`);
+        }
+        // Check if this is a multi-package manifest
+        if ('packages' in manifest && Array.isArray(manifest.packages)) {
+            const multiManifest = manifest;
+            // Validate each package in the array
+            const validatedManifests = multiManifest.packages.map((pkg, idx) => {
+                // Inherit top-level fields if not specified in package - using explicit undefined checks
+                const packageWithDefaults = {
+                    name: pkg.name,
+                    version: pkg.version,
+                    description: pkg.description,
+                    format: pkg.format,
+                    files: pkg.files,
+                    author: pkg.author !== undefined ? pkg.author : multiManifest.author,
+                    license: pkg.license !== undefined ? pkg.license : multiManifest.license,
+                    repository: pkg.repository !== undefined ? pkg.repository : multiManifest.repository,
+                    homepage: pkg.homepage !== undefined ? pkg.homepage : multiManifest.homepage,
+                    documentation: pkg.documentation !== undefined ? pkg.documentation : multiManifest.documentation,
+                    organization: pkg.organization !== undefined ? pkg.organization : multiManifest.organization,
+                    private: pkg.private !== undefined ? pkg.private : multiManifest.private,
+                    tags: pkg.tags !== undefined ? pkg.tags : multiManifest.tags,
+                    keywords: pkg.keywords !== undefined ? pkg.keywords : multiManifest.keywords,
+                    subtype: pkg.subtype,
+                    dependencies: pkg.dependencies,
+                    peerDependencies: pkg.peerDependencies,
+                    engines: pkg.engines,
+                    main: pkg.main,
+                };
+                // Debug: Log inheritance only if DEBUG env var is set
+                if (process.env.DEBUG) {
+                    console.log(`\n🔍 Package ${pkg.name} inheritance:`);
+                    console.log(`   - Package-level private: ${pkg.private}`);
+                    console.log(`   - Top-level private: ${multiManifest.private}`);
+                    console.log(`   - Inherited private: ${packageWithDefaults.private}`);
+                    console.log('');
+                }
+                return validateManifest(packageWithDefaults);
+            });
+            return { manifests: validatedManifests, source: 'prpm.json (multi-package)' };
+        }
+        // Single package manifest
         const validated = validateManifest(manifest);
-        return { manifest: validated, source: 'prpm.json' };
+        return { manifests: [validated], source: 'prpm.json' };
     }
     catch (error) {
-        // If it's a validation error, throw it immediately (don't try marketplace.json)
-        if (error instanceof Error && (error.message.includes('Manifest validation failed') ||
+        // Store error for later
+        prpmJsonError = error;
+        // If it's a validation or parsing error, throw it immediately (don't try marketplace.json)
+        if (prpmJsonExists && error instanceof Error && (error.message.includes('Invalid JSON') ||
+            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
+        // Otherwise, prpm.json not found or other error, try marketplace.json
     }
     // Try .claude/marketplace.json (Claude format)
     const marketplaceJsonPath = (0, path_1.join)(process.cwd(), '.claude', 'marketplace.json');
@@ -81,24 +145,52 @@ async function findAndLoadManifest() {
         if (!(0, marketplace_converter_1.validateMarketplaceJson)(marketplaceData)) {
             throw new Error('Invalid marketplace.json format');
         }
-        // Convert marketplace.json to PRPM manifest
-        const manifest = (0, marketplace_converter_1.marketplaceToManifest)(marketplaceData);
-        // Validate the converted manifest
-        const validated = validateManifest(manifest);
-        return { manifest: validated, source: '.claude/marketplace.json' };
+        // Convert each plugin in marketplace.json to a separate PRPM manifest
+        const manifests = [];
+        for (let i = 0; i < marketplaceData.plugins.length; i++) {
+            const manifest = (0, marketplace_converter_1.marketplaceToManifest)(marketplaceData, i);
+            const validated = validateManifest(manifest);
+            manifests.push(validated);
+        }
+        return { manifests, source: '.claude/marketplace.json' };
+    }
+    catch (error) {
+        // marketplace.json not found or invalid at .claude path, try .claude-plugin
+    }
+    // Try .claude-plugin/marketplace.json (alternative Claude format)
+    const marketplaceJsonPluginPath = (0, path_1.join)(process.cwd(), '.claude-plugin', 'marketplace.json');
+    try {
+        const content = await (0, promises_1.readFile)(marketplaceJsonPluginPath, 'utf-8');
+        const marketplaceData = JSON.parse(content);
+        if (!(0, marketplace_converter_1.validateMarketplaceJson)(marketplaceData)) {
+            throw new Error('Invalid marketplace.json format');
+        }
+        // Convert each plugin in marketplace.json to a separate PRPM manifest
+        const manifests = [];
+        for (let i = 0; i < marketplaceData.plugins.length; i++) {
+            const manifest = (0, marketplace_converter_1.marketplaceToManifest)(marketplaceData, i);
+            const validated = validateManifest(manifest);
+            manifests.push(validated);
+        }
+        return { manifests, source: '.claude-plugin/marketplace.json' };
     }
     catch (error) {
         // marketplace.json not found or invalid
     }
-    // Neither file found
+    // No manifest file found
     throw new Error('No manifest file found. Expected either:\n' +
         '  - prpm.json in the current directory, or\n' +
-        '  - .claude/marketplace.json (Claude format)');
+        '  - .claude/marketplace.json (Claude format), or\n' +
+        '  - .claude-plugin/marketplace.json (Claude format)');
 }
 /**
  * Validate package manifest
  */
 function validateManifest(manifest) {
+    // Set default subtype to 'rule' if not provided
+    if (!manifest.subtype) {
+        manifest.subtype = 'rule';
+    }
     // First, validate against JSON schema
     const schemaValidation = (0, schema_validator_1.validateManifestSchema)(manifest);
     if (!schemaValidation.valid) {
@@ -253,50 +345,212 @@ async function handlePublish(options) {
             process.exit(1);
         }
         console.log('📦 Publishing package...\n');
-        // Read and validate manifest
-        console.log('🔍 Validating package manifest...');
-        const { manifest, source } = await findAndLoadManifest();
-        packageName = manifest.name;
-        version = manifest.version;
-        console.log(`   Source: ${source}`);
-        console.log(`   Package: ${manifest.name}@${manifest.version}`);
-        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);
-        // 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`;
+        // Read and validate manifests
+        console.log('🔍 Validating package manifest(s)...');
+        const { manifests, source } = await findAndLoadManifests();
+        if (manifests.length > 1) {
+            console.log(`   Found ${manifests.length} plugins in ${source}`);
+            console.log('   Will publish each plugin separately\n');
         }
-        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.');
-            console.log('   Run without --dry-run to publish.');
-            success = true;
-            return;
-        }
-        // Publish to registry
-        console.log('🚀 Publishing to registry...');
+        // Get user info to check for organizations (once for all packages)
+        console.log('🔍 Checking authentication...');
         const client = (0, registry_client_1.getRegistryClient)(config);
-        const result = await client.publish(manifest, tarball);
-        console.log('');
-        console.log('✅ Package published successfully!');
-        console.log('');
-        console.log(`   Package: ${manifest.name}@${result.version}`);
-        console.log(`   Install: prpm install ${manifest.name}`);
-        console.log(`   View: ${config.registryUrl}/packages/${result.package_id}`);
+        let userInfo;
+        try {
+            userInfo = await client.whoami();
+        }
+        catch (err) {
+            console.log('   Could not fetch user organizations, publishing as personal packages');
+        }
         console.log('');
-        success = true;
+        // Track published packages
+        const publishedPackages = [];
+        const failedPackages = [];
+        // Publish each manifest
+        for (let i = 0; i < manifests.length; i++) {
+            const manifest = manifests[i];
+            packageName = manifest.name;
+            version = manifest.version;
+            if (manifests.length > 1) {
+                console.log(`\n${'='.repeat(60)}`);
+                console.log(`📦 Publishing plugin ${i + 1} of ${manifests.length}`);
+                console.log(`${'='.repeat(60)}\n`);
+            }
+            try {
+                // Debug: Log access override logic only if DEBUG env var is set
+                if (process.env.DEBUG) {
+                    console.log(`\n🔍 Before access override:`);
+                    console.log(`   - manifest.private: ${manifest.private}`);
+                    console.log(`   - options.access: ${options.access}`);
+                }
+                // Determine access level:
+                // 1. If --access flag is provided, it overrides manifest setting
+                // 2. Otherwise, use manifest setting (defaults to false/public if not specified)
+                let isPrivate;
+                if (options.access !== undefined) {
+                    // CLI flag explicitly provided - use it
+                    isPrivate = options.access === 'private';
+                    if (process.env.DEBUG) {
+                        console.log(`   - Using CLI flag override: ${options.access}`);
+                    }
+                }
+                else {
+                    // No CLI flag - use manifest setting
+                    isPrivate = manifest.private || false;
+                    if (process.env.DEBUG) {
+                        console.log(`   - Using manifest setting: ${isPrivate}`);
+                    }
+                }
+                if (process.env.DEBUG) {
+                    console.log(`   - calculated isPrivate: ${isPrivate}`);
+                }
+                // Update manifest with final private setting
+                manifest.private = isPrivate;
+                if (process.env.DEBUG) {
+                    console.log(`   - final manifest.private: ${manifest.private}`);
+                    console.log('');
+                }
+                let selectedOrgId;
+                // Check if organization is specified in manifest
+                if (manifest.organization && userInfo) {
+                    const orgFromManifest = userInfo.organizations?.find((org) => org.name === manifest.organization || org.id === manifest.organization);
+                    if (!orgFromManifest) {
+                        throw new Error(`Organization "${manifest.organization}" not found or you are not a member`);
+                    }
+                    // Check if user has publishing rights
+                    if (!['owner', 'admin', 'maintainer'].includes(orgFromManifest.role)) {
+                        throw new Error(`You do not have permission to publish to organization "${orgFromManifest.name}". ` +
+                            `Your role: ${orgFromManifest.role}. Required: owner, admin, or maintainer`);
+                    }
+                    selectedOrgId = orgFromManifest.id;
+                }
+                console.log(`   Source: ${source}`);
+                console.log(`   Package: ${manifest.name}@${manifest.version}`);
+                console.log(`   Format: ${manifest.format} | Subtype: ${manifest.subtype}`);
+                console.log(`   Description: ${manifest.description}`);
+                console.log(`   Access: ${manifest.private ? 'private' : 'public'}`);
+                if (selectedOrgId && userInfo) {
+                    const selectedOrg = userInfo.organizations.find((org) => org.id === selectedOrgId);
+                    console.log(`   Publishing to: ${selectedOrg?.name || 'organization'}`);
+                }
+                console.log('');
+                // Extract license information
+                console.log('📄 Extracting license information...');
+                const licenseInfo = await (0, license_extractor_1.extractLicenseInfo)(manifest.repository);
+                // Update manifest with license information from LICENSE file if found
+                // Only set fields that aren't already manually specified in prpm.json
+                if (licenseInfo.type && !manifest.license) {
+                    manifest.license = licenseInfo.type;
+                }
+                if (licenseInfo.text && !manifest.license_text) {
+                    manifest.license_text = licenseInfo.text;
+                }
+                if (licenseInfo.url && !manifest.license_url) {
+                    manifest.license_url = licenseInfo.url || undefined;
+                }
+                // Validate and warn about license (optional - will extract if present)
+                (0, license_extractor_1.validateLicenseInfo)(licenseInfo, manifest.name);
+                console.log('');
+                // Extract content snippet
+                console.log('📝 Extracting content snippet...');
+                const snippet = await (0, snippet_extractor_1.extractSnippet)(manifest);
+                if (snippet) {
+                    manifest.snippet = snippet;
+                }
+                (0, snippet_extractor_1.validateSnippet)(snippet, manifest.name);
+                console.log('');
+                // Create tarball
+                console.log('📦 Creating package tarball...');
+                const tarball = await createTarball(manifest);
+                // 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.');
+                    publishedPackages.push({
+                        name: manifest.name,
+                        version: manifest.version,
+                        url: ''
+                    });
+                    continue;
+                }
+                // Publish to registry
+                console.log('🚀 Publishing to registry...');
+                const result = await client.publish(manifest, tarball, selectedOrgId ? { orgId: selectedOrgId } : undefined);
+                // Determine the webapp URL based on registry URL
+                let webappUrl;
+                const registryUrl = config.registryUrl || 'https://registry.prpm.dev';
+                if (registryUrl.includes('localhost') || registryUrl.includes('127.0.0.1')) {
+                    // Local development - webapp is on port 5173
+                    webappUrl = 'http://localhost:5173';
+                }
+                else if (registryUrl.includes('registry.prpm.dev')) {
+                    // Production - webapp is on prpm.dev
+                    webappUrl = 'https://prpm.dev';
+                }
+                else {
+                    // Default to registry URL for unknown environments
+                    webappUrl = registryUrl;
+                }
+                const packageUrl = `${webappUrl}/packages/${encodeURIComponent(manifest.name)}`;
+                console.log('');
+                console.log('✅ Package published successfully!');
+                console.log('');
+                console.log(`   Package: ${manifest.name}@${result.version}`);
+                console.log(`   Install: prpm install ${manifest.name}`);
+                console.log('');
+                publishedPackages.push({
+                    name: manifest.name,
+                    version: result.version,
+                    url: packageUrl
+                });
+            }
+            catch (err) {
+                const pkgError = err instanceof Error ? err.message : String(err);
+                console.error(`\n❌ Failed to publish ${manifest.name}: ${pkgError}\n`);
+                failedPackages.push({
+                    name: manifest.name,
+                    error: pkgError
+                });
+            }
+        }
+        // Print summary if multiple packages
+        if (manifests.length > 1) {
+            console.log(`\n${'='.repeat(60)}`);
+            console.log(`📊 Publishing Summary`);
+            console.log(`${'='.repeat(60)}\n`);
+            if (publishedPackages.length > 0) {
+                console.log(`✅ Successfully published ${publishedPackages.length} package(s):`);
+                publishedPackages.forEach(pkg => {
+                    console.log(`   - ${pkg.name}@${pkg.version}`);
+                    if (pkg.url) {
+                        console.log(`     ${pkg.url}`);
+                    }
+                });
+                console.log('');
+            }
+            if (failedPackages.length > 0) {
+                console.log(`❌ Failed to publish ${failedPackages.length} package(s):`);
+                failedPackages.forEach(pkg => {
+                    console.log(`   - ${pkg.name}: ${pkg.error}`);
+                });
+                console.log('');
+            }
+        }
+        success = publishedPackages.length > 0;
+        if (failedPackages.length > 0 && publishedPackages.length === 0) {
+            process.exit(1);
+        }
     }
     catch (err) {
         error = err instanceof Error ? err.message : String(err);
@@ -353,7 +607,7 @@ async function handlePublish(options) {
 function createPublishCommand() {
     return new commander_1.Command('publish')
         .description('Publish a package to the registry')
-        .option('--access <type>', 'Package access (public or private)', 'public')
+        .option('--access <type>', 'Package access (public or private) - overrides manifest setting')
         .option('--tag <tag>', 'NPM-style tag (e.g., latest, beta)', 'latest')
         .option('--dry-run', 'Validate package without publishing')
         .action(async (options) => {

package/dist/commands/search.js

@@ -54,11 +54,9 @@ function getPackageIcon(format, subtype) {
         'slash-command': '⚡',
         'rule': '📋',
         'prompt': '💬',
-        'workflow': '⚡',
-        'tool': '🔧',
-        'template': '📄',
         'collection': '📦',
         'chatmode': '💬',
+        'tool': '🔧',
     };
     // Format-specific icons for rules/defaults
     const formatIcons = {
@@ -95,11 +93,9 @@ function getPackageLabel(format, subtype) {
         'slash-command': 'Slash Command',
         'rule': 'Rule',
         'prompt': 'Prompt',
-        'workflow': 'Workflow',
-        'tool': 'Tool',
-        'template': 'Template',
         'collection': 'Collection',
         'chatmode': 'Chat Mode',
+        'tool': 'Tool',
     };
     const formatLabel = formatLabels[format];
     const subtypeLabel = subtypeLabels[subtype];
@@ -409,7 +405,7 @@ function createSearchCommand() {
         const limit = options.limit ? parseInt(options.limit, 10) : 20;
         const page = options.page ? parseInt(options.page, 10) : 1;
         const validFormats = ['cursor', 'claude', 'continue', 'windsurf', 'copilot', 'kiro', 'generic', 'mcp'];
-        const validSubtypes = ['rule', 'agent', 'skill', 'slash-command', 'prompt', 'workflow', 'tool', 'template', 'collection'];
+        const validSubtypes = ['rule', 'agent', 'skill', 'slash-command', 'prompt', 'collection', 'chatmode'];
         if (options.format && !validFormats.includes(format)) {
             console.error(`❌ Format must be one of: ${validFormats.join(', ')}`);
             process.exit(1);

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

@@ -17,8 +17,13 @@ const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 /**
  * Get the destination directory for a package based on format and subtype
+ * @param format - Package format (cursor, claude, etc.)
+ * @param subtype - Package subtype (skill, agent, rule, etc.)
+ * @param name - Package name (optional, only needed for Claude skills which create subdirectories)
  */
-function getDestinationDir(format, subtype) {
+function getDestinationDir(format, subtype, name) {
+    // Strip author namespace from package name to avoid nested directories
+    const packageName = stripAuthorNamespace(name);
     switch (format) {
         case 'cursor':
             if (subtype === 'agent')
@@ -27,6 +32,9 @@ function getDestinationDir(format, subtype) {
                 return '.cursor/commands';
             return '.cursor/rules';
         case 'claude':
+            // Only create subdirectory for skills if name is provided
+            if (subtype === 'skill' && packageName)
+                return `.claude/skills/${packageName}`;
             if (subtype === 'skill')
                 return '.claude/skills';
             if (subtype === 'slash-command')
@@ -124,6 +132,10 @@ function generateId(filename) {
  * stripAuthorNamespace('git-workflow-manager') // 'git-workflow-manager'
  */
 function stripAuthorNamespace(packageId) {
+    // Handle undefined or empty string
+    if (!packageId) {
+        return '';
+    }
     // Split by '/' and get the last segment (the actual package name)
     const parts = packageId.split('/');
     return parts[parts.length - 1];

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) {