prpm 0.0.1

package/dist/core/config.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Configuration management for .promptpm.json
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.addPackage = addPackage;
+exports.removePackage = removePackage;
+exports.getPackage = getPackage;
+exports.listPackages = listPackages;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const CONFIG_FILE = '.promptpm.json';
+/**
+ * Read the configuration file from the current directory
+ */
+async function readConfig() {
+    try {
+        const configPath = path_1.default.resolve(CONFIG_FILE);
+        const data = await fs_1.promises.readFile(configPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        // If file doesn't exist, return empty config
+        if (error.code === 'ENOENT') {
+            return { sources: [] };
+        }
+        throw new Error(`Failed to read config: ${error}`);
+    }
+}
+/**
+ * Write the configuration file to the current directory
+ */
+async function writeConfig(config) {
+    try {
+        const configPath = path_1.default.resolve(CONFIG_FILE);
+        const data = JSON.stringify(config, null, 2);
+        await fs_1.promises.writeFile(configPath, data, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to write config: ${error}`);
+    }
+}
+/**
+ * Add a package to the configuration
+ */
+async function addPackage(pkg) {
+    const config = await readConfig();
+    // Check if package with same ID already exists
+    const existingIndex = config.sources.findIndex(p => p.id === pkg.id);
+    if (existingIndex >= 0) {
+        // Update existing package
+        config.sources[existingIndex] = pkg;
+    }
+    else {
+        // Add new package
+        config.sources.push(pkg);
+    }
+    await writeConfig(config);
+}
+/**
+ * Remove a package from the configuration
+ */
+async function removePackage(id) {
+    const config = await readConfig();
+    const index = config.sources.findIndex(p => p.id === id);
+    if (index === -1) {
+        return null;
+    }
+    const removed = config.sources.splice(index, 1)[0];
+    await writeConfig(config);
+    return removed;
+}
+/**
+ * Get a package by ID
+ */
+async function getPackage(id) {
+    const config = await readConfig();
+    return config.sources.find(p => p.id === id) || null;
+}
+/**
+ * List all packages
+ */
+async function listPackages() {
+    const config = await readConfig();
+    return config.sources;
+}

package/dist/core/downloader.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * HTTP file downloading functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+exports.extractFilename = extractFilename;
+// Use Node.js built-in fetch (available in Node 18+)
+/**
+ * Download a file from a URL
+ */
+async function downloadFile(url) {
+    try {
+        // Validate URL format
+        if (!isValidUrl(url)) {
+            throw new Error('Invalid URL format');
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const content = await response.text();
+        return content;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to download file: ${error.message}`);
+        }
+        throw new Error('Failed to download file: Unknown error');
+    }
+}
+/**
+ * Validate if URL is a valid raw GitHub URL
+ */
+function isValidUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        // For MVP, only support raw GitHub URLs
+        return (urlObj.protocol === 'https:' &&
+            (urlObj.hostname === 'raw.githubusercontent.com' ||
+                urlObj.hostname === 'github.com' && urlObj.pathname.includes('/raw/')));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract filename from URL
+ */
+function extractFilename(url) {
+    try {
+        const urlObj = new URL(url);
+        const pathname = urlObj.pathname;
+        const filename = pathname.split('/').pop() || 'unknown';
+        // If no extension, assume it's a markdown file
+        if (!filename.includes('.')) {
+            return `${filename}.md`;
+        }
+        return filename;
+    }
+    catch {
+        return 'unknown.md';
+    }
+}

package/dist/core/filesystem.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * File system operations for managing prompt files
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDestinationDir = getDestinationDir;
+exports.ensureDirectoryExists = ensureDirectoryExists;
+exports.saveFile = saveFile;
+exports.deleteFile = deleteFile;
+exports.fileExists = fileExists;
+exports.generateId = generateId;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+/**
+ * Get the destination directory for a package type
+ */
+function getDestinationDir(type) {
+    switch (type) {
+        case 'cursor':
+            return '.cursor/rules';
+        case 'claude':
+            return '.claude/agents';
+        default:
+            throw new Error(`Unknown package type: ${type}`);
+    }
+}
+/**
+ * Ensure directory exists, creating it if necessary
+ */
+async function ensureDirectoryExists(dirPath) {
+    try {
+        await fs_1.promises.mkdir(dirPath, { recursive: true });
+    }
+    catch (error) {
+        throw new Error(`Failed to create directory ${dirPath}: ${error}`);
+    }
+}
+/**
+ * Save content to a file
+ */
+async function saveFile(filePath, content) {
+    try {
+        // Ensure parent directory exists
+        const dir = path_1.default.dirname(filePath);
+        await ensureDirectoryExists(dir);
+        // Write file
+        await fs_1.promises.writeFile(filePath, content, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save file ${filePath}: ${error}`);
+    }
+}
+/**
+ * Delete a file
+ */
+async function deleteFile(filePath) {
+    try {
+        await fs_1.promises.unlink(filePath);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            // File doesn't exist, that's fine
+            return;
+        }
+        throw new Error(`Failed to delete file ${filePath}: ${error}`);
+    }
+}
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath) {
+    try {
+        await fs_1.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Generate a unique ID from filename
+ */
+function generateId(filename) {
+    // Remove extension and convert to kebab-case
+    const name = filename.replace(/\.[^/.]+$/, '');
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}

package/dist/core/lockfile.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Lock file management for reproducible installations
+ * prpm.lock format similar to package-lock.json
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLockfile = readLockfile;
+exports.writeLockfile = writeLockfile;
+exports.createLockfile = createLockfile;
+exports.addToLockfile = addToLockfile;
+exports.setPackageIntegrity = setPackageIntegrity;
+exports.verifyPackageIntegrity = verifyPackageIntegrity;
+exports.getLockedVersion = getLockedVersion;
+exports.isLockfileOutOfSync = isLockfileOutOfSync;
+exports.mergeLockfiles = mergeLockfiles;
+exports.pruneLockfile = pruneLockfile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const LOCKFILE_NAME = 'prpm.lock';
+const LOCKFILE_VERSION = 1;
+/**
+ * Read lock file from current directory
+ */
+async function readLockfile(cwd = process.cwd()) {
+    try {
+        const lockfilePath = (0, path_1.join)(cwd, LOCKFILE_NAME);
+        const content = await fs_1.promises.readFile(lockfilePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null; // Lock file doesn't exist
+        }
+        throw new Error(`Failed to read lock file: ${error}`);
+    }
+}
+/**
+ * Write lock file to current directory
+ */
+async function writeLockfile(lockfile, cwd = process.cwd()) {
+    try {
+        const lockfilePath = (0, path_1.join)(cwd, LOCKFILE_NAME);
+        const content = JSON.stringify(lockfile, null, 2);
+        await fs_1.promises.writeFile(lockfilePath, content, 'utf-8');
+    }
+    catch (error) {
+        throw new Error(`Failed to write lock file: ${error}`);
+    }
+}
+/**
+ * Create new lock file
+ */
+function createLockfile() {
+    return {
+        version: '1.0.0',
+        lockfileVersion: LOCKFILE_VERSION,
+        packages: {},
+        generated: new Date().toISOString(),
+    };
+}
+/**
+ * Add package to lock file
+ */
+function addToLockfile(lockfile, packageId, packageInfo) {
+    lockfile.packages[packageId] = {
+        version: packageInfo.version,
+        resolved: packageInfo.tarballUrl,
+        integrity: '', // Will be set after download
+        dependencies: packageInfo.dependencies,
+        type: packageInfo.type,
+        format: packageInfo.format,
+    };
+    lockfile.generated = new Date().toISOString();
+}
+/**
+ * Update package integrity hash after download
+ */
+function setPackageIntegrity(lockfile, packageId, tarballBuffer) {
+    if (!lockfile.packages[packageId]) {
+        throw new Error(`Package ${packageId} not found in lock file`);
+    }
+    const hash = (0, crypto_1.createHash)('sha256').update(tarballBuffer).digest('hex');
+    lockfile.packages[packageId].integrity = `sha256-${hash}`;
+}
+/**
+ * Verify package integrity
+ */
+function verifyPackageIntegrity(lockfile, packageId, tarballBuffer) {
+    const pkg = lockfile.packages[packageId];
+    if (!pkg || !pkg.integrity) {
+        return false;
+    }
+    const hash = (0, crypto_1.createHash)('sha256').update(tarballBuffer).digest('hex');
+    const expectedHash = pkg.integrity.replace('sha256-', '');
+    return hash === expectedHash;
+}
+/**
+ * Get locked version for a package
+ */
+function getLockedVersion(lockfile, packageId) {
+    if (!lockfile || !lockfile.packages[packageId]) {
+        return null;
+    }
+    return lockfile.packages[packageId].version;
+}
+/**
+ * Check if lock file is out of sync with dependencies
+ */
+function isLockfileOutOfSync(lockfile, requiredPackages) {
+    if (!lockfile) {
+        return true;
+    }
+    // Check if all required packages are in lock file
+    for (const [pkgId, version] of Object.entries(requiredPackages)) {
+        const locked = lockfile.packages[pkgId];
+        if (!locked || locked.version !== version) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Merge lock files (for conflict resolution)
+ */
+function mergeLockfiles(base, incoming) {
+    const merged = createLockfile();
+    // Merge packages from both lock files
+    const allPackages = new Set([
+        ...Object.keys(base.packages),
+        ...Object.keys(incoming.packages),
+    ]);
+    for (const pkgId of allPackages) {
+        const basePkg = base.packages[pkgId];
+        const incomingPkg = incoming.packages[pkgId];
+        if (!basePkg) {
+            merged.packages[pkgId] = incomingPkg;
+        }
+        else if (!incomingPkg) {
+            merged.packages[pkgId] = basePkg;
+        }
+        else {
+            // Both exist - prefer newer version
+            const baseVersion = basePkg.version;
+            const incomingVersion = incomingPkg.version;
+            merged.packages[pkgId] = compareVersions(baseVersion, incomingVersion) >= 0
+                ? basePkg
+                : incomingPkg;
+        }
+    }
+    return merged;
+}
+/**
+ * Simple semver comparison (returns 1 if a > b, -1 if a < b, 0 if equal)
+ */
+function compareVersions(a, b) {
+    const aParts = a.split('.').map(Number);
+    const bParts = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const aVal = aParts[i] || 0;
+        const bVal = bParts[i] || 0;
+        if (aVal > bVal)
+            return 1;
+        if (aVal < bVal)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * Prune unused packages from lock file
+ */
+function pruneLockfile(lockfile, requiredPackages) {
+    const pruned = { ...lockfile };
+    pruned.packages = {};
+    for (const pkgId of requiredPackages) {
+        if (lockfile.packages[pkgId]) {
+            pruned.packages[pkgId] = lockfile.packages[pkgId];
+        }
+    }
+    pruned.generated = new Date().toISOString();
+    return pruned;
+}

package/dist/core/registry-client.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * Registry API Client
+ * Handles all communication with the PRMP Registry
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryClient = void 0;
+exports.getRegistryClient = getRegistryClient;
+class RegistryClient {
+    constructor(config) {
+        this.baseUrl = config.url.replace(/\/$/, ''); // Remove trailing slash
+        this.token = config.token;
+    }
+    /**
+     * Search for packages in the registry
+     */
+    async search(query, options) {
+        const params = new URLSearchParams({ q: query });
+        if (options?.type)
+            params.append('type', options.type);
+        if (options?.tags)
+            options.tags.forEach(tag => params.append('tags', tag));
+        if (options?.limit)
+            params.append('limit', options.limit.toString());
+        if (options?.offset)
+            params.append('offset', options.offset.toString());
+        const response = await this.fetch(`/api/v1/search?${params}`);
+        return response.json();
+    }
+    /**
+     * Get package information
+     */
+    async getPackage(packageId) {
+        const response = await this.fetch(`/api/v1/packages/${packageId}`);
+        return response.json();
+    }
+    /**
+     * Get specific package version
+     */
+    async getPackageVersion(packageId, version) {
+        const response = await this.fetch(`/api/v1/packages/${packageId}/${version}`);
+        return response.json();
+    }
+    /**
+     * Get package dependencies
+     */
+    async getPackageDependencies(packageId, version) {
+        const versionPath = version ? `/${version}` : '';
+        const response = await this.fetch(`/api/v1/packages/${packageId}${versionPath}/dependencies`);
+        return response.json();
+    }
+    /**
+     * Get all versions for a package
+     */
+    async getPackageVersions(packageId) {
+        const response = await this.fetch(`/api/v1/packages/${packageId}/versions`);
+        return response.json();
+    }
+    /**
+     * Resolve dependency tree
+     */
+    async resolveDependencies(packageId, version) {
+        const params = new URLSearchParams();
+        if (version)
+            params.append('version', version);
+        const response = await this.fetch(`/api/v1/packages/${packageId}/resolve?${params}`);
+        return response.json();
+    }
+    /**
+     * Download package tarball
+     */
+    async downloadPackage(tarballUrl, options = {}) {
+        // If format is specified and tarballUrl is from registry, append format param
+        let url = tarballUrl;
+        if (options.format && tarballUrl.includes(this.baseUrl)) {
+            const urlObj = new URL(tarballUrl);
+            urlObj.searchParams.set('format', options.format);
+            url = urlObj.toString();
+        }
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to download package: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    /**
+     * Get trending packages
+     */
+    async getTrending(type, limit = 20) {
+        const params = new URLSearchParams({ limit: limit.toString() });
+        if (type)
+            params.append('type', type);
+        const response = await this.fetch(`/api/v1/search/trending?${params}`);
+        const data = await response.json();
+        return data.packages;
+    }
+    /**
+     * Get featured packages
+     */
+    async getFeatured(type, limit = 20) {
+        const params = new URLSearchParams({ limit: limit.toString() });
+        if (type)
+            params.append('type', type);
+        const response = await this.fetch(`/api/v1/search/featured?${params}`);
+        const data = await response.json();
+        return data.packages;
+    }
+    /**
+     * Publish a package (requires authentication)
+     */
+    async publish(manifest, tarball) {
+        if (!this.token) {
+            throw new Error('Authentication required. Run `prpm login` first.');
+        }
+        const formData = new FormData();
+        formData.append('manifest', JSON.stringify(manifest));
+        formData.append('tarball', new Blob([tarball]), 'package.tar.gz');
+        const response = await this.fetch('/api/v1/packages', {
+            method: 'POST',
+            body: formData,
+        });
+        return response.json();
+    }
+    /**
+     * Login and get authentication token
+     */
+    async login() {
+        // This will open browser for GitHub OAuth
+        // For now, return placeholder - will implement OAuth flow
+        throw new Error('Login not yet implemented. Coming soon!');
+    }
+    /**
+     * Get current user info
+     */
+    async whoami() {
+        if (!this.token) {
+            throw new Error('Not authenticated. Run `prpm login` first.');
+        }
+        const response = await this.fetch('/api/v1/auth/me');
+        return response.json();
+    }
+    /**
+     * Get collections
+     */
+    async getCollections(options) {
+        const params = new URLSearchParams();
+        if (options?.category)
+            params.append('category', options.category);
+        if (options?.tag)
+            params.append('tag', options.tag);
+        if (options?.official)
+            params.append('official', 'true');
+        if (options?.scope)
+            params.append('scope', options.scope);
+        if (options?.limit)
+            params.append('limit', options.limit.toString());
+        if (options?.offset)
+            params.append('offset', options.offset.toString());
+        const response = await this.fetch(`/api/v1/collections?${params}`);
+        return response.json();
+    }
+    /**
+     * Get collection details
+     */
+    async getCollection(scope, id, version) {
+        const versionPath = version ? `/${version}` : '/1.0.0';
+        const response = await this.fetch(`/api/v1/collections/${scope}/${id}${versionPath}`);
+        return response.json();
+    }
+    /**
+     * Install collection (get installation plan)
+     */
+    async installCollection(options) {
+        const params = new URLSearchParams();
+        if (options.format)
+            params.append('format', options.format);
+        if (options.skipOptional)
+            params.append('skipOptional', 'true');
+        const versionPath = options.version ? `@${options.version}` : '';
+        const response = await this.fetch(`/api/v1/collections/${options.scope}/${options.id}${versionPath}/install?${params}`, { method: 'POST' });
+        return response.json();
+    }
+    /**
+     * Create a collection (requires authentication)
+     */
+    async createCollection(data) {
+        if (!this.token) {
+            throw new Error('Authentication required. Run `prpm login` first.');
+        }
+        const response = await this.fetch('/api/v1/collections', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+        return response.json();
+    }
+    /**
+     * Helper method for making authenticated requests with retry logic
+     */
+    async fetch(path, options = {}, retries = 3) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+        if (this.token) {
+            headers['Authorization'] = `Bearer ${this.token}`;
+        }
+        let lastError = null;
+        for (let attempt = 0; attempt < retries; attempt++) {
+            try {
+                const response = await fetch(url, {
+                    ...options,
+                    headers,
+                });
+                // Handle rate limiting with retry
+                if (response.status === 429) {
+                    const retryAfter = response.headers.get('Retry-After');
+                    const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : Math.pow(2, attempt) * 1000;
+                    if (attempt < retries - 1) {
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                        continue;
+                    }
+                }
+                // Handle server errors with retry
+                if (response.status >= 500 && response.status < 600 && attempt < retries - 1) {
+                    const waitTime = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    continue;
+                }
+                if (!response.ok) {
+                    const error = await response.json().catch(() => ({ error: response.statusText }));
+                    throw new Error(error.error || error.message || `HTTP ${response.status}: ${response.statusText}`);
+                }
+                return response;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // Network errors - retry with exponential backoff
+                if (attempt < retries - 1 && (lastError.message.includes('fetch failed') ||
+                    lastError.message.includes('ECONNREFUSED') ||
+                    lastError.message.includes('ETIMEDOUT'))) {
+                    const waitTime = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    continue;
+                }
+                // If it's not a retryable error or we're out of retries, throw
+                if (attempt === retries - 1) {
+                    throw lastError;
+                }
+            }
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+}
+exports.RegistryClient = RegistryClient;
+/**
+ * Get registry client with configuration
+ */
+function getRegistryClient(config) {
+    return new RegistryClient({
+        url: config.registryUrl || 'https://registry.prpm.dev',
+        token: config.token,
+    });
+}