pcu 0.2.6

package/dist/domain/value-objects/WorkspacePath.js

@@ -0,0 +1,128 @@
+/**
+ * WorkspacePath Value Object
+ *
+ * Represents a file system path to a pnpm workspace.
+ * This is an immutable value object that validates and normalizes workspace paths.
+ */
+import path from 'path';
+import { fileURLToPath } from 'url';
+export class WorkspacePath {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Create a WorkspacePath from a string
+     */
+    static fromString(pathString) {
+        if (!pathString || pathString.trim().length === 0) {
+            throw new Error('WorkspacePath cannot be empty');
+        }
+        // Normalize the path
+        const normalized = path.resolve(pathString.trim());
+        return new WorkspacePath(normalized);
+    }
+    /**
+     * Create a WorkspacePath from the current working directory
+     */
+    static current() {
+        return new WorkspacePath(process.cwd());
+    }
+    /**
+     * Create a WorkspacePath from file URL (useful for ES modules)
+     */
+    static fromFileURL(fileUrl) {
+        const filePath = fileURLToPath(fileUrl);
+        const directory = path.dirname(filePath);
+        return new WorkspacePath(directory);
+    }
+    /**
+     * Get the absolute path as a string
+     */
+    toString() {
+        return this.value;
+    }
+    /**
+     * Get the directory name (last part of the path)
+     */
+    getDirectoryName() {
+        return path.basename(this.value);
+    }
+    /**
+     * Join with another path segment
+     */
+    join(...segments) {
+        const joined = path.join(this.value, ...segments);
+        return new WorkspacePath(joined);
+    }
+    /**
+     * Get the parent directory
+     */
+    getParent() {
+        const parent = path.dirname(this.value);
+        return new WorkspacePath(parent);
+    }
+    /**
+     * Check if this path is a subdirectory of another path
+     */
+    isSubdirectoryOf(other) {
+        const relativePath = path.relative(other.value, this.value);
+        return !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+    }
+    /**
+     * Get relative path from another WorkspacePath
+     */
+    relativeTo(other) {
+        return path.relative(other.value, this.value);
+    }
+    /**
+     * Check equality with another WorkspacePath
+     */
+    equals(other) {
+        return path.resolve(this.value) === path.resolve(other.value);
+    }
+    /**
+     * Get the value for serialization
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Convert to JSON representation
+     */
+    toJSON() {
+        return this.value;
+    }
+    /**
+     * Create from JSON representation
+     */
+    static fromJSON(json) {
+        return WorkspacePath.fromString(json);
+    }
+    /**
+     * Check if this path exists (requires async validation in infrastructure layer)
+     */
+    async exists() {
+        try {
+            const fs = await import('fs/promises');
+            await fs.access(this.value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get the path to pnpm-workspace.yaml
+     */
+    getPnpmWorkspaceConfigPath() {
+        return this.join('pnpm-workspace.yaml');
+    }
+    /**
+     * Get the path to package.json
+     */
+    getPackageJsonPath() {
+        return this.join('package.json');
+    }
+}
+//# sourceMappingURL=WorkspacePath.js.map

package/dist/domain/value-objects/WorkspacePath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkspacePath.js","sourceRoot":"","sources":["../../../src/domain/value-objects/WorkspacePath.ts"],"names":[],"mappings":"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"}

package/dist/infrastructure/cache/Cache.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Cache System
+ *
+ * Provides caching capabilities for NPM registry responses and other expensive operations.
+ * Supports both in-memory and file-based caching with TTL and size limits.
+ */
+export interface CacheEntry<T = any> {
+    key: string;
+    value: T;
+    timestamp: number;
+    ttl: number;
+    size: number;
+}
+export interface CacheOptions {
+    ttl?: number;
+    maxSize?: number;
+    maxEntries?: number;
+    persistToDisk?: boolean;
+    cacheDir?: string;
+}
+export interface CacheStats {
+    totalEntries: number;
+    totalSize: number;
+    hitRate: number;
+    missRate: number;
+    hits: number;
+    misses: number;
+}
+export declare class Cache<T = any> {
+    private entries;
+    private stats;
+    private options;
+    constructor(name: string, options?: CacheOptions);
+    /**
+     * Get value from cache
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: T, ttl?: number): void;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): boolean;
+    /**
+     * Delete entry from cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all cache entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): CacheStats;
+    /**
+     * Get or set with factory function
+     */
+    getOrSet(key: string, factory: () => Promise<T> | T, ttl?: number): Promise<T>;
+    /**
+     * Cleanup expired entries
+     */
+    private cleanup;
+    /**
+     * Ensure cache capacity doesn't exceed limits
+     */
+    private ensureCapacity;
+    /**
+     * Evict oldest entry
+     */
+    private evictOldest;
+    /**
+     * Get total cache size
+     */
+    private getTotalSize;
+    /**
+     * Estimate size of value in bytes
+     */
+    private estimateSize;
+    /**
+     * Load cache from disk
+     */
+    private loadFromDisk;
+    /**
+     * Save entry to disk
+     */
+    private saveToDisk;
+    /**
+     * Delete entry from disk
+     */
+    private deleteFromDisk;
+    /**
+     * Clear disk cache
+     */
+    private clearDisk;
+    /**
+     * Update disk index
+     */
+    private updateDiskIndex;
+    /**
+     * Get filename for cache key
+     */
+    private getFilename;
+}
+/**
+ * Registry-specific cache for NPM API responses
+ */
+export declare class RegistryCache extends Cache<any> {
+    constructor(options?: CacheOptions);
+    /**
+     * Cache package info
+     */
+    setPackageInfo(packageName: string, info: any, ttl?: number): void;
+    /**
+     * Get cached package info
+     */
+    getPackageInfo(packageName: string): any | undefined;
+    /**
+     * Cache version list
+     */
+    setVersions(packageName: string, versions: string[], ttl?: number): void;
+    /**
+     * Get cached versions
+     */
+    getVersions(packageName: string): string[] | undefined;
+    /**
+     * Cache security report
+     */
+    setSecurityReport(packageName: string, version: string, report: any, ttl?: number): void;
+    /**
+     * Get cached security report
+     */
+    getSecurityReport(packageName: string, version: string): any | undefined;
+}
+/**
+ * Workspace-specific cache for file system operations
+ */
+export declare class WorkspaceCache extends Cache<any> {
+    constructor(options?: CacheOptions);
+    /**
+     * Cache workspace info
+     */
+    setWorkspaceInfo(workspacePath: string, info: any, ttl?: number): void;
+    /**
+     * Get cached workspace info
+     */
+    getWorkspaceInfo(workspacePath: string): any | undefined;
+    /**
+     * Cache package.json content
+     */
+    setPackageJson(filePath: string, content: any, ttl?: number): void;
+    /**
+     * Get cached package.json
+     */
+    getPackageJson(filePath: string): any | undefined;
+}
+export declare const registryCache: RegistryCache;
+export declare const workspaceCache: WorkspaceCache;
+//# sourceMappingURL=Cache.d.ts.map

package/dist/infrastructure/cache/Cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/cache/Cache.ts"],"names":[],"mappings":"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"}

package/dist/infrastructure/cache/Cache.js

@@ -0,0 +1,398 @@
+/**
+ * Cache System
+ *
+ * Provides caching capabilities for NPM registry responses and other expensive operations.
+ * Supports both in-memory and file-based caching with TTL and size limits.
+ */
+import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+export class Cache {
+    entries = new Map();
+    stats = {
+        hits: 0,
+        misses: 0,
+    };
+    options;
+    constructor(name, options = {}) {
+        this.options = {
+            ttl: options.ttl || 3600000, // 1 hour default
+            maxSize: options.maxSize || 50 * 1024 * 1024, // 50MB default
+            maxEntries: options.maxEntries || 1000,
+            persistToDisk: options.persistToDisk || false,
+            cacheDir: options.cacheDir || join(homedir(), '.pcu', 'cache', name),
+        };
+        if (this.options.persistToDisk) {
+            this.loadFromDisk();
+        }
+        // Setup cleanup interval
+        setInterval(() => this.cleanup(), 300000); // Clean every 5 minutes
+    }
+    /**
+     * Get value from cache
+     */
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return undefined;
+        }
+        // Check if entry has expired
+        if (Date.now() - entry.timestamp > entry.ttl) {
+            this.entries.delete(key);
+            this.stats.misses++;
+            return undefined;
+        }
+        this.stats.hits++;
+        return entry.value;
+    }
+    /**
+     * Set value in cache
+     */
+    set(key, value, ttl) {
+        const entryTtl = ttl || this.options.ttl;
+        const size = this.estimateSize(value);
+        const entry = {
+            key,
+            value,
+            timestamp: Date.now(),
+            ttl: entryTtl,
+            size,
+        };
+        // Remove old entry if exists
+        if (this.entries.has(key)) {
+            this.entries.delete(key);
+        }
+        // Check size limits before adding
+        this.ensureCapacity(size);
+        this.entries.set(key, entry);
+        if (this.options.persistToDisk) {
+            this.saveToDisk(key, entry);
+        }
+    }
+    /**
+     * Check if key exists in cache
+     */
+    has(key) {
+        const entry = this.entries.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check if expired
+        if (Date.now() - entry.timestamp > entry.ttl) {
+            this.entries.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Delete entry from cache
+     */
+    delete(key) {
+        const deleted = this.entries.delete(key);
+        if (deleted && this.options.persistToDisk) {
+            this.deleteFromDisk(key);
+        }
+        return deleted;
+    }
+    /**
+     * Clear all cache entries
+     */
+    clear() {
+        this.entries.clear();
+        this.stats.hits = 0;
+        this.stats.misses = 0;
+        if (this.options.persistToDisk) {
+            this.clearDisk();
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            totalEntries: this.entries.size,
+            totalSize: this.getTotalSize(),
+            hitRate: total > 0 ? this.stats.hits / total : 0,
+            missRate: total > 0 ? this.stats.misses / total : 0,
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+        };
+    }
+    /**
+     * Get or set with factory function
+     */
+    async getOrSet(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const value = await factory();
+        this.set(key, value, ttl);
+        return value;
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        const expiredKeys = [];
+        for (const [key, entry] of this.entries) {
+            if (now - entry.timestamp > entry.ttl) {
+                expiredKeys.push(key);
+            }
+        }
+        for (const key of expiredKeys) {
+            this.delete(key);
+        }
+    }
+    /**
+     * Ensure cache capacity doesn't exceed limits
+     */
+    ensureCapacity(newEntrySize) {
+        // Check entry count limit
+        while (this.entries.size >= this.options.maxEntries) {
+            this.evictOldest();
+        }
+        // Check size limit
+        while (this.getTotalSize() + newEntrySize > this.options.maxSize) {
+            this.evictOldest();
+        }
+    }
+    /**
+     * Evict oldest entry
+     */
+    evictOldest() {
+        let oldestKey;
+        let oldestTimestamp = Date.now();
+        for (const [key, entry] of this.entries) {
+            if (entry.timestamp < oldestTimestamp) {
+                oldestTimestamp = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            this.delete(oldestKey);
+        }
+    }
+    /**
+     * Get total cache size
+     */
+    getTotalSize() {
+        let totalSize = 0;
+        for (const entry of this.entries.values()) {
+            totalSize += entry.size;
+        }
+        return totalSize;
+    }
+    /**
+     * Estimate size of value in bytes
+     */
+    estimateSize(value) {
+        try {
+            return JSON.stringify(value).length * 2; // Rough UTF-16 estimate
+        }
+        catch {
+            return 1000; // Default estimate for non-serializable values
+        }
+    }
+    /**
+     * Load cache from disk
+     */
+    loadFromDisk() {
+        try {
+            if (!existsSync(this.options.cacheDir)) {
+                return;
+            }
+            const indexPath = join(this.options.cacheDir, 'index.json');
+            if (!existsSync(indexPath)) {
+                return;
+            }
+            const indexContent = readFileSync(indexPath, 'utf-8');
+            const index = JSON.parse(indexContent);
+            for (const key of index.keys || []) {
+                try {
+                    const entryPath = join(this.options.cacheDir, this.getFilename(key));
+                    if (existsSync(entryPath)) {
+                        const entryContent = readFileSync(entryPath, 'utf-8');
+                        const entry = JSON.parse(entryContent);
+                        // Check if entry is still valid
+                        if (Date.now() - entry.timestamp <= entry.ttl) {
+                            this.entries.set(key, entry);
+                        }
+                    }
+                }
+                catch {
+                    // Skip corrupted entries
+                }
+            }
+        }
+        catch {
+            // Ignore disk loading errors
+        }
+    }
+    /**
+     * Save entry to disk
+     */
+    saveToDisk(key, entry) {
+        try {
+            if (!existsSync(this.options.cacheDir)) {
+                mkdirSync(this.options.cacheDir, { recursive: true });
+            }
+            const entryPath = join(this.options.cacheDir, this.getFilename(key));
+            writeFileSync(entryPath, JSON.stringify(entry), 'utf-8');
+            // Update index
+            this.updateDiskIndex();
+        }
+        catch {
+            // Ignore disk saving errors
+        }
+    }
+    /**
+     * Delete entry from disk
+     */
+    deleteFromDisk(key) {
+        try {
+            const entryPath = join(this.options.cacheDir, this.getFilename(key));
+            if (existsSync(entryPath)) {
+                unlinkSync(entryPath);
+            }
+            this.updateDiskIndex();
+        }
+        catch {
+            // Ignore disk deletion errors
+        }
+    }
+    /**
+     * Clear disk cache
+     */
+    clearDisk() {
+        try {
+            if (existsSync(this.options.cacheDir)) {
+                const fs = require('fs');
+                fs.rmSync(this.options.cacheDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Ignore disk clearing errors
+        }
+    }
+    /**
+     * Update disk index
+     */
+    updateDiskIndex() {
+        try {
+            const indexPath = join(this.options.cacheDir, 'index.json');
+            const index = {
+                keys: Array.from(this.entries.keys()),
+                lastUpdated: Date.now(),
+            };
+            writeFileSync(indexPath, JSON.stringify(index), 'utf-8');
+        }
+        catch {
+            // Ignore index update errors
+        }
+    }
+    /**
+     * Get filename for cache key
+     */
+    getFilename(key) {
+        // Use hash to create safe filename
+        const hash = createHash('md5').update(key).digest('hex');
+        return `${hash}.json`;
+    }
+}
+/**
+ * Registry-specific cache for NPM API responses
+ */
+export class RegistryCache extends Cache {
+    constructor(options = {}) {
+        super('registry', {
+            ttl: 3600000, // 1 hour
+            maxSize: 10 * 1024 * 1024, // 10MB
+            maxEntries: 500,
+            persistToDisk: true,
+            ...options,
+        });
+    }
+    /**
+     * Cache package info
+     */
+    setPackageInfo(packageName, info, ttl) {
+        this.set(`package:${packageName}`, info, ttl);
+    }
+    /**
+     * Get cached package info
+     */
+    getPackageInfo(packageName) {
+        return this.get(`package:${packageName}`);
+    }
+    /**
+     * Cache version list
+     */
+    setVersions(packageName, versions, ttl) {
+        this.set(`versions:${packageName}`, versions, ttl);
+    }
+    /**
+     * Get cached versions
+     */
+    getVersions(packageName) {
+        return this.get(`versions:${packageName}`);
+    }
+    /**
+     * Cache security report
+     */
+    setSecurityReport(packageName, version, report, ttl) {
+        this.set(`security:${packageName}:${version}`, report, ttl);
+    }
+    /**
+     * Get cached security report
+     */
+    getSecurityReport(packageName, version) {
+        return this.get(`security:${packageName}:${version}`);
+    }
+}
+/**
+ * Workspace-specific cache for file system operations
+ */
+export class WorkspaceCache extends Cache {
+    constructor(options = {}) {
+        super('workspace', {
+            ttl: 300000, // 5 minutes (shorter TTL for file system)
+            maxSize: 5 * 1024 * 1024, // 5MB
+            maxEntries: 200,
+            persistToDisk: false, // Don't persist workspace cache
+            ...options,
+        });
+    }
+    /**
+     * Cache workspace info
+     */
+    setWorkspaceInfo(workspacePath, info, ttl) {
+        this.set(`workspace:${workspacePath}`, info, ttl);
+    }
+    /**
+     * Get cached workspace info
+     */
+    getWorkspaceInfo(workspacePath) {
+        return this.get(`workspace:${workspacePath}`);
+    }
+    /**
+     * Cache package.json content
+     */
+    setPackageJson(filePath, content, ttl) {
+        this.set(`package-json:${filePath}`, content, ttl);
+    }
+    /**
+     * Get cached package.json
+     */
+    getPackageJson(filePath) {
+        return this.get(`package-json:${filePath}`);
+    }
+}
+// Export singleton instances
+export const registryCache = new RegistryCache();
+export const workspaceCache = new WorkspaceCache();
+//# sourceMappingURL=Cache.js.map