prpm 0.2.0 → 1.0.0

package/dist/core/telemetry.js

@@ -1,253 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.telemetry = void 0;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const posthog_node_1 = require("posthog-node");
-const user_config_1 = require("./user-config");
-class Telemetry {
-    constructor() {
-        this.events = [];
-        this.maxEvents = 100; // Keep only last 100 events locally
-        this.posthog = null;
-        this.userConfigChecked = false;
-        this.userTelemetryEnabled = true; // Default to true until checked
-        this.configPath = path_1.default.join(os_1.default.homedir(), '.prpm', 'telemetry.json');
-        this.config = this.loadConfig();
-    }
-    async checkUserConfig() {
-        if (this.userConfigChecked)
-            return;
-        try {
-            const userConfig = await (0, user_config_1.getConfig)();
-            this.userTelemetryEnabled = userConfig.telemetryEnabled ?? true;
-        }
-        catch (error) {
-            // If we can't load user config, default to enabled
-            this.userTelemetryEnabled = true;
-        }
-        this.userConfigChecked = true;
-    }
-    async initializePostHog() {
-        // Check user config first
-        await this.checkUserConfig();
-        // Only initialize if telemetry is enabled in user config
-        if (!this.userTelemetryEnabled) {
-            this.posthog = null;
-            return;
-        }
-        try {
-            this.posthog = new posthog_node_1.PostHog('phc_aO5lXLILeylHfb1ynszVwKbQKSzO91UGdXNhN5Q0Snl', {
-                host: 'https://app.posthog.com',
-                flushAt: 1, // Send events immediately
-                flushInterval: 0, // No batching
-            });
-        }
-        catch (error) {
-            this.posthog = null;
-        }
-    }
-    loadConfig() {
-        try {
-            const data = require(this.configPath);
-            return {
-                enabled: data.enabled ?? true, // Default to enabled
-                userId: data.userId,
-                sessionId: data.sessionId || this.generateSessionId(),
-            };
-        }
-        catch {
-            return {
-                enabled: true,
-                sessionId: this.generateSessionId(),
-            };
-        }
-    }
-    /**
-     * Load userId from user config and update telemetry config
-     */
-    async loadUserIdFromConfig() {
-        try {
-            const userConfig = await (0, user_config_1.getConfig)();
-            if (userConfig.userId && userConfig.userId !== this.config.userId) {
-                this.config.userId = userConfig.userId;
-                await this.saveConfig();
-            }
-        }
-        catch {
-            // Silently fail - telemetry shouldn't break the CLI
-        }
-    }
-    generateSessionId() {
-        return Math.random().toString(36).substring(2, 15) +
-            Math.random().toString(36).substring(2, 15);
-    }
-    async saveConfig() {
-        try {
-            await fs_1.promises.mkdir(path_1.default.dirname(this.configPath), { recursive: true });
-            await fs_1.promises.writeFile(this.configPath, JSON.stringify(this.config, null, 2));
-        }
-        catch (error) {
-            // Silently fail - telemetry shouldn't break the CLI
-        }
-    }
-    async track(event) {
-        // Check user config first
-        await this.checkUserConfig();
-        // Return early if telemetry is disabled in user config
-        if (!this.userTelemetryEnabled)
-            return;
-        if (!this.config.enabled)
-            return;
-        // Load userId from user config before tracking
-        await this.loadUserIdFromConfig();
-        const fullEvent = {
-            ...event,
-            timestamp: new Date().toISOString(),
-            version: process.env.npm_package_version || '0.1.0',
-            platform: os_1.default.platform(),
-            arch: os_1.default.arch(),
-            nodeVersion: process.version,
-        };
-        this.events.push(fullEvent);
-        // Keep only the last maxEvents
-        if (this.events.length > this.maxEvents) {
-            this.events = this.events.slice(-this.maxEvents);
-        }
-        // Save events locally
-        await this.saveEvents();
-        // Send to analytics service (async, non-blocking)
-        this.sendToAnalytics(fullEvent).catch(() => {
-            // Silently fail - don't break the CLI
-        });
-    }
-    async saveEvents() {
-        try {
-            const eventsPath = path_1.default.join(os_1.default.homedir(), '.prpm', 'events.json');
-            await fs_1.promises.mkdir(path_1.default.dirname(eventsPath), { recursive: true });
-            await fs_1.promises.writeFile(eventsPath, JSON.stringify(this.events, null, 2));
-        }
-        catch (error) {
-            // Silently fail
-        }
-    }
-    async sendToAnalytics(event) {
-        // Initialize PostHog if needed (this will check user config)
-        if (!this.posthog && this.userTelemetryEnabled) {
-            await this.initializePostHog();
-        }
-        // Send to PostHog
-        await this.sendToPostHog(event);
-    }
-    async enable() {
-        this.config.enabled = true;
-        await this.saveConfig();
-    }
-    async disable() {
-        this.config.enabled = false;
-        await this.saveConfig();
-    }
-    async isEnabled() {
-        await this.checkUserConfig();
-        return this.userTelemetryEnabled && this.config.enabled;
-    }
-    async getStats() {
-        try {
-            const eventsPath = path_1.default.join(os_1.default.homedir(), '.prpm', 'events.json');
-            const data = await fs_1.promises.readFile(eventsPath, 'utf8');
-            const savedEvents = JSON.parse(data);
-            return {
-                totalEvents: savedEvents.length,
-                lastEvent: savedEvents[savedEvents.length - 1]?.timestamp,
-            };
-        }
-        catch (error) {
-            return {
-                totalEvents: this.events.length,
-                lastEvent: this.events[this.events.length - 1]?.timestamp,
-            };
-        }
-    }
-    async shutdown() {
-        if (this.posthog) {
-            try {
-                // Flush any pending events before shutdown
-                await this.posthog.flush();
-                await this.posthog.shutdown();
-            }
-            catch (error) {
-                // Silently fail
-            }
-            finally {
-                this.posthog = null;
-            }
-        }
-    }
-    /**
-     * Identify user in PostHog with user properties
-     * Called after successful login to set user attributes
-     */
-    async identifyUser(userId, traits) {
-        if (!this.posthog || !this.config.enabled)
-            return;
-        try {
-            // Update local config with userId
-            this.config.userId = userId;
-            await this.saveConfig();
-            // Send $identify event to PostHog
-            this.posthog.identify({
-                distinctId: userId,
-                properties: traits,
-            });
-            // Also capture the $identify event explicitly
-            this.posthog.capture({
-                distinctId: userId,
-                event: '$identify',
-                properties: traits,
-            });
-            // Flush immediately to ensure identification happens
-            await this.posthog.flush();
-        }
-        catch (error) {
-            // Silently fail - telemetry shouldn't break the CLI
-        }
-    }
-    // Send to PostHog
-    async sendToPostHog(event) {
-        if (!this.posthog)
-            return;
-        try {
-            const distinctId = this.config.userId || this.config.sessionId || 'anonymous';
-            this.posthog.capture({
-                distinctId,
-                event: `prpm_${event.command}`,
-                properties: {
-                    // Core event data
-                    command: event.command,
-                    success: event.success,
-                    duration: event.duration,
-                    error: event.error,
-                    // System information
-                    version: event.version,
-                    platform: event.platform,
-                    arch: event.arch,
-                    nodeVersion: event.nodeVersion,
-                    // Command-specific data
-                    ...event.data,
-                    // Metadata
-                    timestamp: event.timestamp,
-                    sessionId: this.config.sessionId,
-                },
-            });
-            // Event sent to PostHog
-        }
-        catch (error) {
-            // Silently fail - don't break the CLI
-        }
-    }
-}
-exports.telemetry = new Telemetry();

package/dist/core/user-config.js

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

package/dist/types/registry.js

@@ -1,12 +0,0 @@
-"use strict";
-/**
- * Registry API types for CLI
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isMultiPackageManifest = isMultiPackageManifest;
-/**
- * Type guard to check if manifest is multi-package
- */
-function isMultiPackageManifest(manifest) {
-    return 'packages' in manifest && Array.isArray(manifest.packages);
-}

package/dist/types.js

@@ -1,9 +0,0 @@
-"use strict";
-/**
- * Core types for the Prompt Package Manager
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUBTYPES = exports.FORMATS = void 0;
-var types_1 = require("@pr-pm/types");
-Object.defineProperty(exports, "FORMATS", { enumerable: true, get: function () { return types_1.FORMATS; } });
-Object.defineProperty(exports, "SUBTYPES", { enumerable: true, get: function () { return types_1.SUBTYPES; } });

package/dist/utils/license-extractor.js

@@ -1,122 +0,0 @@
-"use strict";
-/**
- * License extraction utilities
- * Extracts license information from LICENSE files for proper attribution
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractLicenseInfo = extractLicenseInfo;
-exports.validateLicenseInfo = validateLicenseInfo;
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-const fs_1 = require("fs");
-/**
- * Common license file names to search for
- */
-const LICENSE_FILE_PATTERNS = [
-    'LICENSE',
-    'LICENSE.md',
-    'LICENSE.txt',
-    'LICENCE',
-    'LICENCE.md',
-    'LICENCE.txt',
-    'LICENSE-MIT',
-    'LICENSE-APACHE',
-    'COPYING',
-    'COPYING.txt',
-];
-/**
- * License type detection patterns
- * Ordered by specificity - more specific patterns first
- */
-const LICENSE_PATTERNS = [
-    { pattern: /MIT License/i, type: 'MIT' },
-    { pattern: /Apache License[\s\S]*Version 2\.0/i, type: 'Apache-2.0' },
-    { pattern: /GNU GENERAL PUBLIC LICENSE[\s\S]*Version 3/i, type: 'GPL-3.0' },
-    { pattern: /GNU GENERAL PUBLIC LICENSE[\s\S]*Version 2/i, type: 'GPL-2.0' },
-    { pattern: /GNU LESSER GENERAL PUBLIC LICENSE[\s\S]*Version 3/i, type: 'LGPL-3.0' },
-    { pattern: /GNU LESSER GENERAL PUBLIC LICENSE[\s\S]*Version 2/i, type: 'LGPL-2.1' },
-    { pattern: /BSD 3-Clause License/i, type: 'BSD-3-Clause' },
-    { pattern: /BSD 2-Clause License/i, type: 'BSD-2-Clause' },
-    { pattern: /Mozilla Public License[\s\S]*Version 2\.0/i, type: 'MPL-2.0' },
-    { pattern: /ISC License/i, type: 'ISC' },
-    { pattern: /The Unlicense/i, type: 'Unlicense' },
-    { pattern: /Creative Commons Zero[\s\S]*1\.0/i, type: 'CC0-1.0' },
-];
-/**
- * Detect license type from license text
- */
-function detectLicenseType(text) {
-    for (const { pattern, type } of LICENSE_PATTERNS) {
-        if (pattern.test(text)) {
-            return type;
-        }
-    }
-    return null;
-}
-/**
- * Generate GitHub raw URL for license file
- */
-function generateLicenseUrl(repositoryUrl, fileName) {
-    if (!repositoryUrl) {
-        return null;
-    }
-    // Extract owner/repo from GitHub URL
-    const githubMatch = repositoryUrl.match(/github\.com[/:]([\w-]+)\/([\w-]+)/);
-    if (!githubMatch) {
-        return null;
-    }
-    const [, owner, repo] = githubMatch;
-    // Use raw.githubusercontent.com for direct file access
-    return `https://raw.githubusercontent.com/${owner}/${repo}/main/${fileName}`;
-}
-/**
- * Find and extract license information from the current directory
- */
-async function extractLicenseInfo(repositoryUrl) {
-    const cwd = process.cwd();
-    // Try each license file pattern
-    for (const fileName of LICENSE_FILE_PATTERNS) {
-        const filePath = (0, path_1.join)(cwd, fileName);
-        try {
-            // Check if file exists
-            await (0, promises_1.access)(filePath, fs_1.constants.R_OK);
-            // Read license file
-            const text = await (0, promises_1.readFile)(filePath, 'utf-8');
-            // Detect license type
-            const type = detectLicenseType(text);
-            // Generate license URL if repository is provided
-            const url = generateLicenseUrl(repositoryUrl, fileName);
-            return {
-                type,
-                text,
-                url,
-                fileName,
-            };
-        }
-        catch {
-            // File doesn't exist or can't be read, try next pattern
-            continue;
-        }
-    }
-    // No license file found
-    return {
-        type: null,
-        text: null,
-        url: null,
-        fileName: null,
-    };
-}
-/**
- * Display license information if found
- */
-function validateLicenseInfo(licenseInfo, packageName) {
-    if (licenseInfo.text && licenseInfo.type) {
-        console.log(`   License: ${licenseInfo.type} (${licenseInfo.fileName})`);
-    }
-    else if (licenseInfo.text && !licenseInfo.type) {
-        console.log(`   License: Found (${licenseInfo.fileName})`);
-    }
-    else {
-        console.log(`   License: Not found (package will be published without license)`);
-    }
-}

package/dist/utils/multi-package.js

@@ -1,117 +0,0 @@
-"use strict";
-/**
- * Multi-package manifest utilities
- * Handles merging root-level fields with package-level fields
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergePackageFields = mergePackageFields;
-exports.getPackagesWithInheritance = getPackagesWithInheritance;
-exports.validateMultiPackageManifest = validateMultiPackageManifest;
-exports.filterPackages = filterPackages;
-/**
- * Fields that can be inherited from root to packages
- */
-const INHERITABLE_FIELDS = [
-    'author',
-    'license',
-    'repository',
-    'homepage',
-    'documentation',
-    'organization',
-    'keywords',
-    'tags',
-];
-/**
- * Merge root-level fields into a package manifest
- * Package-level fields take precedence over root-level fields
- */
-function mergePackageFields(root, pkg) {
-    const merged = { ...pkg };
-    // Inherit each inheritable field if not defined in package
-    for (const field of INHERITABLE_FIELDS) {
-        if (merged[field] === undefined && root[field] !== undefined) {
-            // @ts-ignore - dynamic field access
-            merged[field] = root[field];
-        }
-    }
-    return merged;
-}
-/**
- * Get all packages from a multi-package manifest with inherited fields
- */
-function getPackagesWithInheritance(manifest) {
-    return manifest.packages.map(pkg => mergePackageFields(manifest, pkg));
-}
-/**
- * Validate multi-package manifest
- */
-function validateMultiPackageManifest(manifest) {
-    const errors = [];
-    // Check packages array exists and is not empty
-    if (!manifest.packages || !Array.isArray(manifest.packages)) {
-        errors.push('packages field must be an array');
-        return { valid: false, errors };
-    }
-    if (manifest.packages.length === 0) {
-        errors.push('packages array must contain at least one package');
-        return { valid: false, errors };
-    }
-    // Check for duplicate package names
-    const names = new Set();
-    for (let i = 0; i < manifest.packages.length; i++) {
-        const pkg = manifest.packages[i];
-        if (names.has(pkg.name)) {
-            errors.push(`Duplicate package name: ${pkg.name}`);
-        }
-        names.add(pkg.name);
-    }
-    // Validate each package has required fields
-    for (let i = 0; i < manifest.packages.length; i++) {
-        const pkg = manifest.packages[i];
-        const pkgPrefix = `Package ${i} (${pkg.name || 'unnamed'})`;
-        if (!pkg.name) {
-            errors.push(`${pkgPrefix}: missing required field 'name'`);
-        }
-        if (!pkg.version) {
-            errors.push(`${pkgPrefix}: missing required field 'version'`);
-        }
-        if (!pkg.description) {
-            errors.push(`${pkgPrefix}: missing required field 'description'`);
-        }
-        if (!pkg.format) {
-            errors.push(`${pkgPrefix}: missing required field 'format'`);
-        }
-        if (!pkg.files || pkg.files.length === 0) {
-            errors.push(`${pkgPrefix}: must have at least one file in 'files' array`);
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}
-/**
- * Filter packages by name or pattern
- */
-function filterPackages(packages, filter) {
-    // If filter is a number, treat as index
-    if (typeof filter === 'number') {
-        if (filter < 0 || filter >= packages.length) {
-            throw new Error(`Package index ${filter} out of range (0-${packages.length - 1})`);
-        }
-        return [packages[filter]];
-    }
-    // If exact match, return that package
-    const exactMatch = packages.find(pkg => pkg.name === filter);
-    if (exactMatch) {
-        return [exactMatch];
-    }
-    // Try as glob pattern
-    const pattern = filter.replace(/\*/g, '.*');
-    const regex = new RegExp(`^${pattern}$`);
-    const matches = packages.filter(pkg => regex.test(pkg.name));
-    if (matches.length === 0) {
-        throw new Error(`No packages match filter: ${filter}`);
-    }
-    return matches;
-}