prpm 0.0.12 → 0.0.14

package/dist/commands/catalog.js

@@ -0,0 +1,348 @@
+"use strict";
+/**
+ * Catalog command - Discover and catalog existing packages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCatalog = handleCatalog;
+exports.createCatalogCommand = createCatalogCommand;
+const commander_1 = require("commander");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const telemetry_1 = require("../core/telemetry");
+/**
+ * Detect format and subtype from file path and content
+ */
+function detectPackageInfo(filePath, content) {
+    const fileName = (0, path_1.basename)(filePath);
+    const lowerFileName = fileName.toLowerCase();
+    // Claude skills - SKILL.md files
+    if (fileName === 'SKILL.md') {
+        const dirName = (0, path_1.basename)((0, path_1.join)(filePath, '..'));
+        return {
+            format: 'claude',
+            subtype: 'skill',
+            name: dirName.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        };
+    }
+    // Claude agents
+    if (filePath.includes('.claude/agents') || filePath.includes('.claude-plugin/agents')) {
+        return {
+            format: 'claude',
+            subtype: 'agent',
+            name: fileName.replace(/\.(md|txt)$/, '').toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        };
+    }
+    // Cursor rules
+    if (filePath.includes('.cursor/rules') || lowerFileName.endsWith('.mdc')) {
+        return {
+            format: 'cursor',
+            subtype: 'rule',
+            name: fileName.replace(/\.(md|mdc|txt)$/, '').toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        };
+    }
+    // Windsurf rules
+    if (filePath.includes('.windsurf/rules')) {
+        return {
+            format: 'windsurf',
+            subtype: 'rule',
+            name: fileName.replace(/\.(md|txt)$/, '').toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        };
+    }
+    // Continue config
+    if (filePath.includes('.continue/prompts')) {
+        return {
+            format: 'continue',
+            subtype: 'prompt',
+            name: fileName.replace(/\.(md|txt)$/, '').toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        };
+    }
+    // Generic markdown files in root that look like prompts
+    if (lowerFileName.endsWith('.md') && content.length > 50) {
+        return {
+            format: 'generic',
+            subtype: 'prompt',
+            name: fileName.replace(/\.md$/, '').toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+        };
+    }
+    return null;
+}
+/**
+ * Recursively scan directories for packages
+ */
+async function scanDirectory(dirPath, baseDir, scanDir, maxDepth = 5, currentDepth = 0) {
+    if (currentDepth > maxDepth) {
+        return [];
+    }
+    const discovered = [];
+    try {
+        const entries = await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = (0, path_1.join)(dirPath, entry.name);
+            const relativePath = (0, path_1.relative)(baseDir, fullPath);
+            // Skip node_modules, .git, and other common dirs
+            if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist' || entry.name === 'build') {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                // Recursively scan subdirectories
+                const subDirPackages = await scanDirectory(fullPath, baseDir, scanDir, maxDepth, currentDepth + 1);
+                discovered.push(...subDirPackages);
+            }
+            else if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdc') || entry.name.endsWith('.txt'))) {
+                // Check if this is a package file
+                try {
+                    const content = await (0, promises_1.readFile)(fullPath, 'utf-8');
+                    const packageInfo = detectPackageInfo(fullPath, content);
+                    if (packageInfo) {
+                        discovered.push({
+                            path: relativePath,
+                            format: packageInfo.format,
+                            subtype: packageInfo.subtype,
+                            name: packageInfo.name,
+                            files: [relativePath],
+                            scanDir,
+                        });
+                    }
+                }
+                catch (err) {
+                    // Skip files we can't read
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Skip directories we can't read
+    }
+    return discovered;
+}
+/**
+ * Extract description from file content
+ * Tries multiple strategies:
+ * 1. YAML frontmatter (---\ndescription: ...\n---)
+ * 2. Markdown description field (description: ...)
+ * 3. First substantial paragraph after title
+ */
+function extractDescription(content) {
+    const lines = content.split('\n');
+    // Strategy 1: YAML frontmatter
+    if (lines[0]?.trim() === '---') {
+        let foundClosing = false;
+        let frontmatterLines = [];
+        for (let i = 1; i < lines.length && i < 50; i++) {
+            const line = lines[i];
+            if (line.trim() === '---') {
+                foundClosing = true;
+                break;
+            }
+            frontmatterLines.push(line);
+        }
+        if (foundClosing && frontmatterLines.length > 0) {
+            // Parse YAML-like frontmatter
+            for (const line of frontmatterLines) {
+                const match = line.match(/^description:\s*(.+)$/i);
+                if (match) {
+                    return match[1].trim().replace(/^["']|["']$/g, '').substring(0, 200);
+                }
+            }
+        }
+    }
+    // Strategy 2: Look for "description:" field anywhere in first 20 lines
+    for (let i = 0; i < Math.min(lines.length, 20); i++) {
+        const line = lines[i];
+        const match = line.match(/^description:\s*(.+)$/i);
+        if (match) {
+            return match[1].trim().replace(/^["']|["']$/g, '').substring(0, 200);
+        }
+    }
+    // Strategy 3: First substantial non-header paragraph
+    let foundTitle = false;
+    for (let i = 0; i < Math.min(lines.length, 30); i++) {
+        const line = lines[i].trim();
+        // Skip empty lines and YAML frontmatter
+        if (line === '' || line === '---') {
+            continue;
+        }
+        // Skip markdown headers
+        if (line.startsWith('#')) {
+            foundTitle = true;
+            continue;
+        }
+        // Found a substantial line after the title
+        if (foundTitle && line.length >= 20 && !line.startsWith('```')) {
+            return line.substring(0, 200);
+        }
+        // If no title found yet but line is substantial, use it
+        if (!foundTitle && line.length >= 30) {
+            return line.substring(0, 200);
+        }
+    }
+    return null;
+}
+/**
+ * Discover packages in specified directories
+ */
+async function handleCatalog(directories, options) {
+    const startTime = Date.now();
+    let success = false;
+    let error;
+    try {
+        console.log('🔍 Scanning for packages...\n');
+        const allDiscovered = [];
+        // Scan each directory
+        for (const dir of directories) {
+            console.log(`   Scanning ${dir}...`);
+            try {
+                const dirStat = await (0, promises_1.stat)(dir);
+                if (!dirStat.isDirectory()) {
+                    console.log(`   ⚠️  Skipping ${dir} (not a directory)`);
+                    continue;
+                }
+                const discovered = await scanDirectory(dir, dir, dir);
+                allDiscovered.push(...discovered);
+                console.log(`   Found ${discovered.length} package(s) in ${dir}`);
+            }
+            catch (err) {
+                console.log(`   ⚠️  Could not access ${dir}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        console.log(`\n✨ Discovered ${allDiscovered.length} package(s) total:\n`);
+        if (allDiscovered.length === 0) {
+            console.log('No packages found. Try scanning different directories.');
+            success = true;
+            return;
+        }
+        // Display discovered packages
+        const byFormat = new Map();
+        for (const pkg of allDiscovered) {
+            if (!byFormat.has(pkg.format)) {
+                byFormat.set(pkg.format, []);
+            }
+            byFormat.get(pkg.format).push(pkg);
+        }
+        for (const [format, packages] of byFormat.entries()) {
+            console.log(`📦 ${format} (${packages.length}):`);
+            for (const pkg of packages) {
+                console.log(`   - ${pkg.name} (${pkg.subtype}): ${pkg.path}`);
+            }
+            console.log('');
+        }
+        if (options.dryRun) {
+            console.log('🔍 Dry run - would update prpm.json\n');
+            success = true;
+            return;
+        }
+        // Load or create prpm.json
+        const prpmJsonPath = options.output || (0, path_1.join)(process.cwd(), 'prpm.json');
+        let manifest;
+        if (options.append) {
+            try {
+                const existingContent = await (0, promises_1.readFile)(prpmJsonPath, 'utf-8');
+                const existing = JSON.parse(existingContent);
+                // Check if it's a multi-package manifest
+                if ('packages' in existing && Array.isArray(existing.packages)) {
+                    manifest = existing;
+                }
+                else {
+                    // Convert single package to multi-package
+                    manifest = {
+                        name: 'multi-package',
+                        version: '1.0.0',
+                        packages: [existing],
+                    };
+                }
+            }
+            catch (err) {
+                // File doesn't exist, create new
+                manifest = {
+                    name: 'multi-package',
+                    version: '1.0.0',
+                    packages: [],
+                };
+            }
+        }
+        else {
+            manifest = {
+                name: 'multi-package',
+                version: '1.0.0',
+                packages: [],
+            };
+        }
+        // Convert discovered packages to manifests
+        const existingNames = new Set(manifest.packages.map(p => p.name));
+        let addedCount = 0;
+        for (const discovered of allDiscovered) {
+            // Skip if already exists
+            if (existingNames.has(discovered.name)) {
+                console.log(`   ⚠️  Skipping ${discovered.name} (already in prpm.json)`);
+                continue;
+            }
+            // Extract description from first file
+            let description = `${discovered.format} ${discovered.subtype}`;
+            try {
+                const firstFilePath = (0, path_1.join)(process.cwd(), discovered.scanDir, discovered.files[0]);
+                const content = await (0, promises_1.readFile)(firstFilePath, 'utf-8');
+                const extractedDesc = extractDescription(content);
+                if (extractedDesc) {
+                    description = extractedDesc;
+                }
+            }
+            catch (err) {
+                // Use default description
+            }
+            const packageManifest = {
+                name: discovered.name,
+                version: '1.0.0',
+                description,
+                author: '', // User should fill this in
+                format: discovered.format,
+                subtype: discovered.subtype,
+                files: discovered.files,
+            };
+            manifest.packages.push(packageManifest);
+            addedCount++;
+        }
+        // Write updated prpm.json
+        await (0, promises_1.writeFile)(prpmJsonPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
+        console.log(`\n✅ Updated ${prpmJsonPath}`);
+        console.log(`   Added ${addedCount} new package(s)`);
+        console.log(`   Total: ${manifest.packages.length} package(s)\n`);
+        console.log('💡 Next steps:');
+        console.log('   1. Review and edit package metadata in prpm.json');
+        console.log('   2. Add author, license, and other fields');
+        console.log('   3. Run: prpm publish --dry-run to validate');
+        console.log('   4. Run: prpm publish to publish packages\n');
+        success = true;
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        console.error(`\n❌ Failed to catalog packages: ${error}\n`);
+        process.exit(1);
+    }
+    finally {
+        await telemetry_1.telemetry.track({
+            command: 'catalog',
+            success,
+            error,
+            duration: Date.now() - startTime,
+            data: {
+                directories: directories.length,
+            },
+        });
+        await telemetry_1.telemetry.shutdown();
+    }
+}
+/**
+ * Create the catalog command
+ */
+function createCatalogCommand() {
+    return new commander_1.Command('catalog')
+        .description('Discover and catalog existing packages from directories')
+        .argument('[directories...]', 'Directories to scan for packages (defaults to current directory)', ['.'])
+        .option('-o, --output <path>', 'Output path for prpm.json (default: ./prpm.json)')
+        .option('-a, --append', 'Append to existing prpm.json instead of overwriting')
+        .option('--dry-run', 'Show what would be cataloged without making changes')
+        .action(async (directories, options) => {
+        await handleCatalog(directories, options);
+        process.exit(0);
+    });
+}

package/dist/commands/collections.js

@@ -47,6 +47,7 @@ const registry_client_1 = require("@pr-pm/registry-client");
 const user_config_1 = require("../core/user-config");
 const install_1 = require("./install");
 const telemetry_1 = require("../core/telemetry");
+const lockfile_1 = require("../core/lockfile");
 /**
  * Search collections by query
  */
@@ -494,6 +495,7 @@ async function handleCollectionInstall(collectionSpec, options) {
             return;
         }
         // Install packages sequentially
+        const installedPackageIds = [];
         for (let i = 0; i < packages.length; i++) {
             const pkg = packages[i];
             const progress = `${i + 1}/${packages.length}`;
@@ -501,8 +503,14 @@ async function handleCollectionInstall(collectionSpec, options) {
                 console.log(`\n  ${progress} Installing ${pkg.packageId}@${pkg.version}...`);
                 await (0, install_1.handleInstall)(`${pkg.packageId}@${pkg.version}`, {
                     as: pkg.format,
+                    fromCollection: {
+                        scope,
+                        name_slug,
+                        version: collection.version || version || '1.0.0',
+                    },
                 });
                 console.log(`  ${progress} ✓ ${pkg.packageId}`);
+                installedPackageIds.push(pkg.packageId);
                 packagesInstalled++;
             }
             catch (error) {
@@ -514,11 +522,22 @@ async function handleCollectionInstall(collectionSpec, options) {
                 }
             }
         }
+        // Update lockfile with collection info
+        const lockfile = (await (0, lockfile_1.readLockfile)()) || (0, lockfile_1.createLockfile)();
+        const collectionKey = `@${scope}/${name_slug}`;
+        (0, lockfile_1.addCollectionToLockfile)(lockfile, collectionKey, {
+            scope,
+            name_slug,
+            version: collection.version || version || '1.0.0',
+            packages: installedPackageIds,
+        });
+        await (0, lockfile_1.writeLockfile)(lockfile);
         console.log(`\n✅ Collection installed successfully!`);
         console.log(`   ${packagesInstalled}/${packages.length} packages installed`);
         if (packagesFailed > 0) {
             console.log(`   ${packagesFailed} optional packages failed`);
         }
+        console.log(`   🔒 Collection tracked in lock file`);
         console.log('');
         await telemetry_1.telemetry.track({
             command: 'collections:install',

package/dist/commands/install.js

@@ -364,6 +364,7 @@ async function handleInstall(packageSpec, options) {
             format: pkg.format, // Preserve original package format
             subtype: pkg.subtype, // Preserve original package subtype
             installedPath: destPath,
+            fromCollection: options.fromCollection,
         });
         (0, lockfile_1.setPackageIntegrity)(updatedLockfile, packageId, tarball);
         await (0, lockfile_1.writeLockfile)(updatedLockfile);

package/dist/commands/publish.js

@@ -363,6 +363,29 @@ async function handlePublish(options) {
             console.log('   Could not fetch user organizations, publishing as personal packages');
         }
         console.log('');
+        // Check for duplicate package names
+        if (manifests.length > 1) {
+            const nameMap = new Map();
+            const duplicates = [];
+            manifests.forEach((manifest, index) => {
+                const existingIndex = nameMap.get(manifest.name);
+                if (existingIndex !== undefined) {
+                    duplicates.push(`  - "${manifest.name}" appears in positions ${existingIndex + 1} and ${index + 1}`);
+                }
+                else {
+                    nameMap.set(manifest.name, index);
+                }
+            });
+            if (duplicates.length > 0) {
+                console.error('❌ Duplicate package names detected:\n');
+                duplicates.forEach(dup => console.error(dup));
+                console.error('\n⚠️  Each package must have a unique name.');
+                console.error('   Package names are globally unique per author/organization.');
+                console.error('   If you want to publish the same package for different formats,');
+                console.error('   use different names (e.g., "react-rules-cursor" vs "react-rules-claude").\n');
+                throw new Error('Cannot publish packages with duplicate names');
+            }
+        }
         // Track published packages
         const publishedPackages = [];
         const failedPackages = [];

package/dist/core/filesystem.js

@@ -13,6 +13,8 @@ exports.deleteFile = deleteFile;
 exports.fileExists = fileExists;
 exports.generateId = generateId;
 exports.stripAuthorNamespace = stripAuthorNamespace;
+exports.getInstalledFilePath = getInstalledFilePath;
+exports.getInstalledFilePaths = getInstalledFilePaths;
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 /**
@@ -140,3 +142,42 @@ function stripAuthorNamespace(packageId) {
     const parts = packageId.split('/');
     return parts[parts.length - 1];
 }
+/**
+ * Get the expected installed file path for a package
+ * This matches the logic used by the install command to determine where files are placed
+ *
+ * @param packageName - Full package name (e.g., '@prpm/typescript-rules')
+ * @param format - Package format
+ * @param subtype - Package subtype
+ * @param fileName - Optional specific file name (defaults to main file)
+ * @returns Path where the file will be installed relative to working directory
+ */
+function getInstalledFilePath(packageName, format, subtype, fileName) {
+    const destDir = getDestinationDir(format, subtype, packageName);
+    const packageBaseName = stripAuthorNamespace(packageName);
+    // If a specific file name is provided, use it
+    if (fileName) {
+        return path_1.default.join(destDir, fileName);
+    }
+    // Claude skills always use SKILL.md
+    if (format === 'claude' && subtype === 'skill') {
+        return path_1.default.join(destDir, 'SKILL.md');
+    }
+    // Determine file extension
+    const fileExtension = format === 'cursor' ? 'mdc' : 'md';
+    // For other formats, use package name as filename
+    return path_1.default.join(destDir, `${packageBaseName}.${fileExtension}`);
+}
+/**
+ * Get all expected installed file paths for a multi-file package
+ *
+ * @param packageName - Full package name
+ * @param format - Package format
+ * @param subtype - Package subtype
+ * @param fileNames - Array of file names in the package
+ * @returns Array of paths where files will be installed
+ */
+function getInstalledFilePaths(packageName, format, subtype, fileNames) {
+    const destDir = getDestinationDir(format, subtype, packageName);
+    return fileNames.map(fileName => path_1.default.join(destDir, fileName));
+}

package/dist/core/lockfile.js

@@ -18,6 +18,10 @@ exports.addPackage = addPackage;
 exports.removePackage = removePackage;
 exports.listPackages = listPackages;
 exports.getPackage = getPackage;
+exports.addCollectionToLockfile = addCollectionToLockfile;
+exports.getCollectionFromLockfile = getCollectionFromLockfile;
+exports.removeCollectionFromLockfile = removeCollectionFromLockfile;
+exports.listCollectionsFromLockfile = listCollectionsFromLockfile;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const crypto_1 = require("crypto");
@@ -75,6 +79,7 @@ function addToLockfile(lockfile, packageId, packageInfo) {
         format: packageInfo.format,
         subtype: packageInfo.subtype,
         installedPath: packageInfo.installedPath,
+        fromCollection: packageInfo.fromCollection,
     };
     lockfile.generated = new Date().toISOString();
 }
@@ -237,3 +242,50 @@ async function getPackage(packageId) {
     }
     return lockfile.packages[packageId];
 }
+/**
+ * Add or update collection in lock file
+ */
+function addCollectionToLockfile(lockfile, collectionKey, collectionInfo) {
+    if (!lockfile.collections) {
+        lockfile.collections = {};
+    }
+    lockfile.collections[collectionKey] = {
+        scope: collectionInfo.scope,
+        name_slug: collectionInfo.name_slug,
+        version: collectionInfo.version,
+        installedAt: new Date().toISOString(),
+        packages: collectionInfo.packages,
+    };
+    lockfile.generated = new Date().toISOString();
+}
+/**
+ * Get collection from lock file
+ */
+function getCollectionFromLockfile(lockfile, collectionKey) {
+    if (!lockfile || !lockfile.collections) {
+        return null;
+    }
+    return lockfile.collections[collectionKey] || null;
+}
+/**
+ * Remove collection from lock file
+ */
+function removeCollectionFromLockfile(lockfile, collectionKey) {
+    if (!lockfile.collections) {
+        return;
+    }
+    delete lockfile.collections[collectionKey];
+    lockfile.generated = new Date().toISOString();
+}
+/**
+ * List all collections in lock file
+ */
+function listCollectionsFromLockfile(lockfile) {
+    if (!lockfile || !lockfile.collections) {
+        return [];
+    }
+    return Object.entries(lockfile.collections).map(([key, collection]) => ({
+        key,
+        ...collection,
+    }));
+}

package/dist/index.js

@@ -25,6 +25,7 @@ const upgrade_1 = require("./commands/upgrade");
 const schema_1 = require("./commands/schema");
 const init_1 = require("./commands/init");
 const config_1 = require("./commands/config");
+const catalog_1 = require("./commands/catalog");
 const telemetry_2 = require("./core/telemetry");
 // Read version from package.json
 function getVersion() {
@@ -44,6 +45,7 @@ program
     .version(getVersion());
 // Package creation commands
 program.addCommand((0, init_1.createInitCommand)());
+program.addCommand((0, catalog_1.createCatalogCommand)());
 // Registry commands (new)
 program.addCommand((0, search_1.createSearchCommand)());
 program.addCommand((0, install_1.createInstallCommand)());

package/dist/utils/snippet-extractor.js

@@ -11,27 +11,34 @@ const path_1 = require("path");
 const MAX_SNIPPET_LENGTH = 2000;
 /**
  * Extract a preview snippet from package files
- * Takes the first file in the package and extracts ~2000 characters
+ * Uses the same path logic as the install command to determine where files will be placed
  */
 async function extractSnippet(manifest) {
     const cwd = process.cwd();
     try {
-        // Get the first file from the manifest
-        const firstFile = manifest.files[0];
-        if (!firstFile) {
+        // Validate manifest has required fields
+        if (!manifest.files || manifest.files.length === 0) {
+            console.warn('⚠️  Cannot extract snippet: no files specified in manifest');
             return null;
         }
-        // Get file path (handle both string and object formats)
-        const filePath = typeof firstFile === 'string'
-            ? firstFile
-            : firstFile.path;
-        // If there's a main file specified, prefer that
-        const targetFile = manifest.main || filePath;
-        const fullPath = (0, path_1.join)(cwd, targetFile);
+        // Prefer main file over first file if specified
+        let fileName;
+        if (manifest.main) {
+            fileName = manifest.main;
+        }
+        else {
+            const firstFile = manifest.files[0];
+            fileName = typeof firstFile === 'string'
+                ? firstFile
+                : firstFile.path;
+        }
+        // Use the file path directly - it should be relative to project root
+        // (e.g., ".claude/skills/my-skill/SKILL.md" or ".cursor/rules/my-rule.mdc")
+        const fullPath = (0, path_1.join)(cwd, fileName);
         // Check if path is a directory
         const stats = await (0, promises_1.stat)(fullPath);
         if (stats.isDirectory()) {
-            console.warn(`⚠️  Skipping snippet extraction: "${targetFile}" is a directory`);
+            console.warn(`⚠️  Skipping snippet extraction: "${fullPath}" is a directory`);
             return null;
         }
         // Read the file content

package/package.json

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