prpm 0.1.15 → 0.1.16

package/dist/commands/collections.js

@@ -507,6 +507,7 @@ async function handleCollectionInstall(collectionSpec, options) {
         }
         // Install packages sequentially
         const installedPackageIds = [];
+        let hasClaudeHooks = false;
         for (let i = 0; i < packages.length; i++) {
             const pkg = packages[i];
             const progress = `${i + 1}/${packages.length}`;
@@ -528,6 +529,10 @@ async function handleCollectionInstall(collectionSpec, options) {
                 if (options.format) {
                     installOptions.as = options.format;
                 }
+                // Track if this collection contains Claude hooks
+                if (pkg.format === 'claude' && pkg.subtype === 'hook') {
+                    hasClaudeHooks = true;
+                }
                 await (0, install_1.handleInstall)(`${pkg.packageId}@${pkg.version}`, installOptions);
                 console.log(`  ${progress} ✓ ${pkg.packageId}`);
                 installedPackageIds.push(pkg.packageId);
@@ -558,6 +563,11 @@ async function handleCollectionInstall(collectionSpec, options) {
             console.log(`   ${packagesFailed} optional packages failed`);
         }
         console.log(`   🔒 Collection tracked in lock file`);
+        // Show Claude hooks warning if any were installed
+        if (hasClaudeHooks) {
+            console.log(`\n⚠️  This collection includes Claude hooks that execute automatically.`);
+            console.log(`   📖 Review hook configurations in .claude/settings.json`);
+        }
         console.log('');
         await telemetry_1.telemetry.track({
             command: 'collections:install',

package/dist/commands/install.js

@@ -224,6 +224,20 @@ async function handleInstall(packageSpec, options) {
         console.log(`   ${pkg.name} ${pkg.official ? '🏅' : ''}`);
         console.log(`   ${pkg.description || 'No description'}`);
         console.log(`   ${typeIcon} Type: ${typeLabel}`);
+        // Check if this is a Claude hook and show informational message
+        if (pkg.format === 'claude' && pkg.subtype === 'hook') {
+            // Only show detailed warning if not part of a collection (to avoid spam)
+            if (!options.fromCollection) {
+                console.log(`\n📌 Installing Claude Hook`);
+                console.log(`   ⚠️  Note: Hooks execute shell commands automatically.`);
+                console.log(`   📖 Review the hook configuration in .claude/settings.json after installation.`);
+                console.log();
+            }
+            else {
+                // Brief message for collection installs
+                console.log(`   🪝 Hook (merges into .claude/settings.json)`);
+            }
+        }
         // Determine format preference with priority order:
         // 1. CLI --as flag (highest priority)
         // 2. defaultFormat from .prpmrc config
@@ -252,7 +266,7 @@ async function handleInstall(packageSpec, options) {
         // 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 { fileExists } = await Promise.resolve().then(() => __importStar(require('../core/filesystem')));
             const claudeMdExists = await fileExists('CLAUDE.md');
             if (!claudeMdExists) {
                 // CLAUDE.md doesn't exist, install as CLAUDE.md (recommended format for Claude Code)
@@ -270,16 +284,19 @@ async function handleInstall(packageSpec, options) {
         }
         // Determine version to install
         let tarballUrl;
+        let actualVersion;
         if (version === 'latest') {
             if (!pkg.latest_version) {
                 throw new Error('No versions available for this package');
             }
             tarballUrl = pkg.latest_version.tarball_url;
+            actualVersion = pkg.latest_version.version;
             console.log(`   📦 Installing version ${pkg.latest_version.version}`);
         }
         else {
             const versionInfo = await client.getPackageVersion(packageId, version);
             tarballUrl = versionInfo.tarball_url;
+            actualVersion = version;
             console.log(`   📦 Installing version ${version}`);
         }
         // Download package in requested format
@@ -295,6 +312,7 @@ async function handleInstall(packageSpec, options) {
         // Track where files were saved for user feedback
         let destPath;
         let fileCount = 0;
+        let hookMetadata = undefined;
         // Special handling for CLAUDE.md format (goes in project root)
         if (format === 'claude-md') {
             if (extractedFiles.length !== 1) {
@@ -321,6 +339,10 @@ async function handleInstall(packageSpec, options) {
             if (effectiveFormat === 'claude' && effectiveSubtype === 'skill') {
                 destPath = `${destDir}/SKILL.md`;
             }
+            else if (effectiveFormat === 'claude' && effectiveSubtype === 'hook') {
+                // Claude hooks are merged into settings.json
+                destPath = `${destDir}/settings.json`;
+            }
             else if (effectiveFormat === 'agents.md') {
                 destPath = `${destDir}/${packageName}/AGENTS.md`;
             }
@@ -361,6 +383,62 @@ async function handleInstall(packageSpec, options) {
                     mainFile = (0, claude_config_1.applyClaudeConfig)(mainFile, config.claude);
                 }
             }
+            // Special handling for Claude hooks - merge into settings.json
+            if (effectiveFormat === 'claude' && effectiveSubtype === 'hook') {
+                const { readFile } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                const { fileExists } = await Promise.resolve().then(() => __importStar(require('../core/filesystem')));
+                // Parse the hook configuration from the downloaded file
+                let hookConfig;
+                try {
+                    hookConfig = JSON.parse(mainFile);
+                }
+                catch (err) {
+                    throw new Error(`Invalid hook configuration: ${err}. Hook file must be valid JSON.`);
+                }
+                // Generate unique hook ID for this installation
+                const hookId = `${packageId}@${actualVersion || version}`;
+                // Read existing settings.json if it exists
+                let existingSettings = { hooks: {} };
+                if (await fileExists(destPath)) {
+                    try {
+                        const existingContent = await readFile(destPath, 'utf-8');
+                        existingSettings = JSON.parse(existingContent);
+                        if (!existingSettings.hooks) {
+                            existingSettings.hooks = {};
+                        }
+                    }
+                    catch (err) {
+                        console.log(`   ⚠️  Warning: Could not parse existing settings.json, creating new one.`);
+                        existingSettings = { hooks: {} };
+                    }
+                }
+                // Track which events this hook adds to
+                const events = [];
+                // Merge the new hook configuration
+                // Assume the downloaded file contains a hooks object
+                if (hookConfig.hooks) {
+                    for (const [event, eventHooks] of Object.entries(hookConfig.hooks)) {
+                        if (!existingSettings.hooks[event]) {
+                            existingSettings.hooks[event] = [];
+                        }
+                        // Add hook ID to each hook config for tracking
+                        const hooksWithId = eventHooks.map(hook => ({
+                            ...hook,
+                            __prpm_hook_id: hookId, // Internal tracking ID
+                        }));
+                        // Add new hooks to the event
+                        existingSettings.hooks[event] = [
+                            ...existingSettings.hooks[event],
+                            ...hooksWithId
+                        ];
+                        events.push(event);
+                    }
+                    console.log(`   ✓ Merged hook configuration into settings.json`);
+                    // Store metadata for lockfile
+                    hookMetadata = { events, hookId };
+                }
+                mainFile = JSON.stringify(existingSettings, null, 2);
+            }
             await (0, filesystem_1.saveFile)(destPath, mainFile);
             fileCount = 1;
         }
@@ -477,7 +555,6 @@ async function handleInstall(packageSpec, options) {
         }
         // Update or create lock file
         const updatedLockfile = lockfile || (0, lockfile_1.createLockfile)();
-        const actualVersion = version === 'latest' ? pkg.latest_version?.version : version;
         (0, lockfile_1.addToLockfile)(updatedLockfile, packageId, {
             version: actualVersion || version,
             tarballUrl,
@@ -485,6 +562,7 @@ async function handleInstall(packageSpec, options) {
             subtype: pkg.subtype, // Preserve original package subtype
             installedPath: destPath,
             fromCollection: options.fromCollection,
+            hookMetadata, // Track hook installation metadata for uninstall
         });
         (0, lockfile_1.setPackageIntegrity)(updatedLockfile, packageId, tarball);
         await (0, lockfile_1.writeLockfile)(updatedLockfile);

package/dist/commands/publish.js

@@ -52,6 +52,7 @@ 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");
+const script_executor_1 = require("../utils/script-executor");
 /**
  * Try to find and load manifest files
  * Checks for:
@@ -357,6 +358,26 @@ async function handlePublish(options) {
         // Read and validate manifests
         console.log('🔍 Validating package manifest(s)...');
         const { manifests, collections, source } = await findAndLoadManifests();
+        // Execute prepublishOnly script if defined (for multi-package manifests)
+        // This runs before any packages are published
+        if (source === 'prpm.json (multi-package)' || source === 'prpm.json') {
+            try {
+                // Re-read the raw prpm.json to check for scripts
+                const prpmJsonPath = (0, path_1.join)(process.cwd(), 'prpm.json');
+                const prpmContent = await (0, promises_1.readFile)(prpmJsonPath, 'utf-8');
+                const prpmManifest = JSON.parse(prpmContent);
+                if (prpmManifest.scripts) {
+                    await (0, script_executor_1.executePrepublishOnly)(prpmManifest.scripts);
+                }
+            }
+            catch (error) {
+                // If script execution fails, abort publish
+                if (error instanceof Error && error.message.includes('script')) {
+                    throw error;
+                }
+                // Ignore other errors (e.g., file not found - shouldn't happen at this point)
+            }
+        }
         if (manifests.length > 1 || collections.length > 0) {
             if (manifests.length > 0) {
                 console.log(`   Found ${manifests.length} package(s) in ${source}`);

package/dist/commands/search.js

@@ -422,7 +422,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', 'agents.md', 'generic', 'mcp'];
-        const validSubtypes = ['rule', 'agent', 'skill', 'slash-command', 'prompt', 'collection', 'chatmode'];
+        const validSubtypes = ['rule', 'agent', 'skill', 'slash-command', 'prompt', 'collection', 'chatmode', 'tool', 'hook'];
         if (options.format && !validFormats.includes(format)) {
             console.error(`❌ Format must be one of: ${validFormats.join(', ')}`);
             throw new errors_1.CLIError(`❌ Format must be one of: ${validFormats.join(', ')}`, 1);

package/dist/commands/uninstall.js

@@ -21,7 +21,46 @@ async function handleUninstall(name) {
         if (!pkg) {
             throw new errors_1.CLIError(`❌ Package "${name}" not found`, 1);
         }
-        // Get the installation path from lock file if available, otherwise calculate it
+        // Special handling for Claude hooks
+        if (pkg.format === 'claude' && pkg.subtype === 'hook' && pkg.hookMetadata) {
+            const settingsPath = pkg.installedPath || '.claude/settings.json';
+            try {
+                // Read settings.json
+                const settingsContent = await fs_1.promises.readFile(settingsPath, 'utf-8');
+                const settings = JSON.parse(settingsContent);
+                if (settings.hooks) {
+                    let removedCount = 0;
+                    // Remove hooks with matching hook ID from each event
+                    for (const event of pkg.hookMetadata.events) {
+                        if (settings.hooks[event]) {
+                            const originalLength = settings.hooks[event].length;
+                            settings.hooks[event] = settings.hooks[event].filter((hook) => hook.__prpm_hook_id !== pkg.hookMetadata.hookId);
+                            const newLength = settings.hooks[event].length;
+                            removedCount += originalLength - newLength;
+                            // Clean up empty event arrays
+                            if (settings.hooks[event].length === 0) {
+                                delete settings.hooks[event];
+                            }
+                        }
+                    }
+                    // Write updated settings back
+                    await fs_1.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+                    console.log(`   🪝 Removed ${removedCount} hook(s) from ${settingsPath}`);
+                }
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'ENOENT') {
+                    console.warn(`   ⚠️  Settings file not found: ${settingsPath}`);
+                }
+                else {
+                    throw new Error(`Failed to remove hooks from settings: ${error}`);
+                }
+            }
+            console.log(`✅ Successfully uninstalled ${name}`);
+            return;
+        }
+        // Standard file/directory uninstall for non-hook packages
         const packageName = (0, filesystem_1.stripAuthorNamespace)(name);
         let targetPath;
         if (pkg.installedPath) {

package/dist/core/filesystem.js

@@ -45,6 +45,9 @@ function getDestinationDir(format, subtype, name) {
                 return '.claude/commands';
             if (subtype === 'agent')
                 return '.claude/agents';
+            // Hooks are configured in settings.json, return .claude directory
+            if (subtype === 'hook')
+                return '.claude';
             return '.claude/agents'; // Default for claude
         case 'continue':
             // Continue has separate directories for prompts (slash commands) and rules

package/dist/core/lockfile.js

@@ -80,6 +80,7 @@ function addToLockfile(lockfile, packageId, packageInfo) {
         subtype: packageInfo.subtype,
         installedPath: packageInfo.installedPath,
         fromCollection: packageInfo.fromCollection,
+        hookMetadata: packageInfo.hookMetadata,
     };
     lockfile.generated = new Date().toISOString();
 }

package/dist/utils/script-executor.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Utility for executing package lifecycle scripts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeScript = executeScript;
+exports.executePrepublishOnly = executePrepublishOnly;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Execute a package lifecycle script
+ * @param script - The script command to execute
+ * @param scriptName - Name of the script (for logging)
+ * @param options - Execution options
+ * @throws Error if script fails
+ */
+async function executeScript(script, scriptName, options = {}) {
+    const { cwd = process.cwd(), timeout = 5 * 60 * 1000, // 5 minutes default
+    maxBuffer = 10 * 1024 * 1024, // 10MB default
+     } = options;
+    console.log(`🔧 Running ${scriptName} script...`);
+    console.log(`   $ ${script}\n`);
+    try {
+        const { stdout, stderr } = await execAsync(script, {
+            cwd,
+            timeout,
+            maxBuffer,
+            // Inherit environment variables
+            env: process.env,
+        });
+        // Show output in real-time
+        if (stdout) {
+            process.stdout.write(stdout);
+        }
+        if (stderr) {
+            process.stderr.write(stderr);
+        }
+        console.log(`\n✓ ${scriptName} script completed successfully\n`);
+        return {
+            stdout,
+            stderr,
+            exitCode: 0,
+        };
+    }
+    catch (error) {
+        // Show error output
+        if (error.stdout) {
+            process.stdout.write(error.stdout);
+        }
+        if (error.stderr) {
+            process.stderr.write(error.stderr);
+        }
+        const errorMessage = error.code === 'ETIMEDOUT'
+            ? `${scriptName} script timed out after ${timeout}ms`
+            : error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER'
+                ? `${scriptName} script output exceeded maximum buffer size`
+                : `${scriptName} script failed with exit code ${error.code || 1}`;
+        throw new Error(errorMessage);
+    }
+}
+/**
+ * Execute prepublishOnly script if defined
+ * @param scripts - Package scripts object
+ * @param options - Execution options
+ */
+async function executePrepublishOnly(scripts, options = {}) {
+    if (!scripts?.prepublishOnly) {
+        return; // No script defined, nothing to do
+    }
+    await executeScript(scripts.prepublishOnly, 'prepublishOnly', options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prpm",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "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.3.13",
-    "@pr-pm/types": "^0.2.14",
+    "@pr-pm/registry-client": "^1.3.14",
+    "@pr-pm/types": "^0.2.15",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^11.1.0",

package/schemas/prpm-manifest.schema.json

@@ -153,6 +153,29 @@
       "description": "Whether the package is private. Private packages are only accessible to the owner/organization members. Defaults to false (public).",
       "default": false
     },
+    "scripts": {
+      "type": "object",
+      "description": "Lifecycle scripts that run during package operations. Only applies to multi-package manifests (prpm.json with packages array).",
+      "properties": {
+        "prepublishOnly": {
+          "type": "string",
+          "description": "Script to run before publishing (recommended - only runs on 'prpm publish')",
+          "examples": [
+            "npm run build",
+            "cd packages/hooks && npm run build",
+            "npm test && npm run build"
+          ]
+        },
+        "prepublish": {
+          "type": "string",
+          "description": "Script to run before publishing and on npm install (not recommended - use prepublishOnly instead)",
+          "examples": [
+            "npm run build"
+          ]
+        }
+      },
+      "additionalProperties": false
+    },
     "tags": {
       "type": "array",
       "description": "Package tags for categorization",