glost-registry 0.5.0

package/dist/types.js

@@ -0,0 +1,9 @@
+/**
+ * Plugin Registry Types
+ *
+ * Type definitions for the enhanced plugin registry.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/validation.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Plugin Validation
+ *
+ * Validation utilities for plugin configurations and dependencies.
+ *
+ * @packageDocumentation
+ */
+import type { PluginMetadata, ValidationResult } from "./types.js";
+/**
+ * Plugin validator
+ */
+export declare class PluginValidator {
+    /**
+     * Validate plugin metadata
+     *
+     * @param metadata - Plugin metadata to validate
+     * @returns Validation result
+     */
+    static validateMetadata(metadata: PluginMetadata): ValidationResult;
+    /**
+     * Validate plugin compatibility with system
+     *
+     * @param metadata - Plugin metadata
+     * @param glostVersion - Current GLOST version
+     * @param nodeVersion - Current Node.js version
+     * @returns Validation result
+     */
+    static validateCompatibility(metadata: PluginMetadata, glostVersion?: string, nodeVersion?: string): ValidationResult;
+    /**
+     * Validate plugin dependencies
+     *
+     * @param metadata - Plugin metadata
+     * @param availablePlugins - Set of available plugin IDs
+     * @returns Validation result
+     */
+    static validateDependencies(metadata: PluginMetadata, availablePlugins: Set<string>): ValidationResult;
+    /**
+     * Check if a version is compatible with a requirement
+     *
+     * @param version - Actual version
+     * @param requirement - Required version or range
+     * @returns True if compatible
+     */
+    private static isVersionCompatible;
+    /**
+     * Check if a string is a valid URL
+     *
+     * @param url - URL to check
+     * @returns True if valid
+     */
+    private static isValidUrl;
+}
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAGjB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,qBAAa,eAAe;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,gBAAgB;IA+FnE;;;;;;;OAOG;IACH,MAAM,CAAC,qBAAqB,CAC1B,QAAQ,EAAE,cAAc,EACxB,YAAY,CAAC,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,gBAAgB;IAiCnB;;;;;;OAMG;IACH,MAAM,CAAC,oBAAoB,CACzB,QAAQ,EAAE,cAAc,EACxB,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,GAC5B,gBAAgB;IAuBnB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoBlC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;CAQ1B"}

package/dist/validation.js

@@ -0,0 +1,204 @@
+/**
+ * Plugin Validation
+ *
+ * Validation utilities for plugin configurations and dependencies.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Plugin validator
+ */
+export class PluginValidator {
+    /**
+     * Validate plugin metadata
+     *
+     * @param metadata - Plugin metadata to validate
+     * @returns Validation result
+     */
+    static validateMetadata(metadata) {
+        const errors = [];
+        const warnings = [];
+        // Check required fields
+        if (!metadata.id) {
+            errors.push({
+                plugin: metadata.id || "unknown",
+                message: "Plugin ID is required",
+                code: "MISSING_ID",
+            });
+        }
+        if (!metadata.name) {
+            errors.push({
+                plugin: metadata.id,
+                message: "Plugin name is required",
+                code: "MISSING_NAME",
+            });
+        }
+        if (!metadata.version) {
+            errors.push({
+                plugin: metadata.id,
+                message: "Plugin version is required",
+                code: "MISSING_VERSION",
+            });
+        }
+        if (!metadata.description) {
+            warnings.push({
+                plugin: metadata.id,
+                message: "Plugin description is recommended",
+                code: "MISSING_DESCRIPTION",
+            });
+        }
+        // Validate version format (basic semver check)
+        if (metadata.version && !/^\d+\.\d+\.\d+/.test(metadata.version)) {
+            warnings.push({
+                plugin: metadata.id,
+                message: "Version should follow semver format (e.g., 1.0.0)",
+                code: "INVALID_VERSION_FORMAT",
+            });
+        }
+        // Validate category
+        const validCategories = [
+            "transformer",
+            "enhancer",
+            "generator",
+            "analyzer",
+            "utility",
+        ];
+        if (!validCategories.includes(metadata.category)) {
+            errors.push({
+                plugin: metadata.id,
+                message: `Invalid category "${metadata.category}". Must be one of: ${validCategories.join(", ")}`,
+                code: "INVALID_CATEGORY",
+            });
+        }
+        // Validate tags
+        if (!metadata.tags || metadata.tags.length === 0) {
+            warnings.push({
+                plugin: metadata.id,
+                message: "At least one tag is recommended for discoverability",
+                code: "MISSING_TAGS",
+            });
+        }
+        // Validate URLs
+        if (metadata.repository && !this.isValidUrl(metadata.repository)) {
+            warnings.push({
+                plugin: metadata.id,
+                message: "Repository URL appears to be invalid",
+                code: "INVALID_REPOSITORY_URL",
+            });
+        }
+        if (metadata.homepage && !this.isValidUrl(metadata.homepage)) {
+            warnings.push({
+                plugin: metadata.id,
+                message: "Homepage URL appears to be invalid",
+                code: "INVALID_HOMEPAGE_URL",
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate plugin compatibility with system
+     *
+     * @param metadata - Plugin metadata
+     * @param glostVersion - Current GLOST version
+     * @param nodeVersion - Current Node.js version
+     * @returns Validation result
+     */
+    static validateCompatibility(metadata, glostVersion, nodeVersion) {
+        const errors = [];
+        const warnings = [];
+        // Check GLOST version requirement
+        if (metadata.requires?.glostVersion && glostVersion) {
+            if (!this.isVersionCompatible(glostVersion, metadata.requires.glostVersion)) {
+                errors.push({
+                    plugin: metadata.id,
+                    message: `Plugin requires GLOST ${metadata.requires.glostVersion}, but ${glostVersion} is installed`,
+                    code: "INCOMPATIBLE_GLOST_VERSION",
+                });
+            }
+        }
+        // Check Node.js version requirement
+        if (metadata.requires?.nodeVersion && nodeVersion) {
+            if (!this.isVersionCompatible(nodeVersion, metadata.requires.nodeVersion)) {
+                errors.push({
+                    plugin: metadata.id,
+                    message: `Plugin requires Node.js ${metadata.requires.nodeVersion}, but ${nodeVersion} is running`,
+                    code: "INCOMPATIBLE_NODE_VERSION",
+                });
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate plugin dependencies
+     *
+     * @param metadata - Plugin metadata
+     * @param availablePlugins - Set of available plugin IDs
+     * @returns Validation result
+     */
+    static validateDependencies(metadata, availablePlugins) {
+        const errors = [];
+        const warnings = [];
+        if (metadata.requires?.plugins) {
+            for (const dep of metadata.requires.plugins) {
+                if (!availablePlugins.has(dep)) {
+                    errors.push({
+                        plugin: metadata.id,
+                        message: `Required plugin "${dep}" is not available`,
+                        code: "MISSING_DEPENDENCY",
+                    });
+                }
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Check if a version is compatible with a requirement
+     *
+     * @param version - Actual version
+     * @param requirement - Required version or range
+     * @returns True if compatible
+     */
+    static isVersionCompatible(version, requirement) {
+        // Simple comparison - in production would use semver library
+        // For now, just check if version >= requirement
+        const versionParts = version.split(".").map(Number);
+        const requirementParts = requirement.replace(/[^\d.]/g, "").split(".").map(Number);
+        for (let i = 0; i < 3; i++) {
+            const v = versionParts[i] || 0;
+            const r = requirementParts[i] || 0;
+            if (v > r)
+                return true;
+            if (v < r)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a string is a valid URL
+     *
+     * @param url - URL to check
+     * @returns True if valid
+     */
+    static isValidUrl(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=validation.js.map

package/dist/validation.js.map

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

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "glost-registry",
+  "version": "0.5.0",
+  "description": "Plugin registry with discovery, metadata, and validation for GLOST",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "keywords": [
+    "glost",
+    "registry",
+    "plugin",
+    "discovery",
+    "metadata"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "glost-core": "0.5.0",
+    "glost-extensions": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.6.0"
+  },
+  "peerDependencies": {
+    "glost-core": "^0.5.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
+}

package/src/discovery.ts

@@ -0,0 +1,315 @@
+/**
+ * Plugin Discovery
+ * 
+ * Utilities for discovering and filtering plugins.
+ * 
+ * @packageDocumentation
+ */
+
+import type { PluginMetadata, PluginQuery, PluginCategory } from "./types.js";
+
+/**
+ * Filter plugins by various criteria
+ */
+export class PluginFilter {
+  /**
+   * Filter plugins by keyword
+   * 
+   * @param plugins - Plugins to filter
+   * @param keyword - Keyword to search for
+   * @returns Filtered plugins
+   */
+  static byKeyword(plugins: PluginMetadata[], keyword: string): PluginMetadata[] {
+    const lowerKeyword = keyword.toLowerCase();
+    return plugins.filter((plugin) => {
+      return (
+        plugin.name.toLowerCase().includes(lowerKeyword) ||
+        plugin.description.toLowerCase().includes(lowerKeyword) ||
+        plugin.id.toLowerCase().includes(lowerKeyword) ||
+        plugin.tags.some((tag) => tag.toLowerCase().includes(lowerKeyword))
+      );
+    });
+  }
+
+  /**
+   * Filter plugins by category
+   * 
+   * @param plugins - Plugins to filter
+   * @param category - Category to filter by
+   * @returns Filtered plugins
+   */
+  static byCategory(
+    plugins: PluginMetadata[],
+    category: PluginCategory
+  ): PluginMetadata[] {
+    return plugins.filter((plugin) => plugin.category === category);
+  }
+
+  /**
+   * Filter plugins by language support
+   * 
+   * @param plugins - Plugins to filter
+   * @param language - Language code
+   * @returns Filtered plugins
+   */
+  static byLanguage(plugins: PluginMetadata[], language: string): PluginMetadata[] {
+    return plugins.filter((plugin) => {
+      return (
+        !plugin.supports.languages ||
+        plugin.supports.languages.includes(language)
+      );
+    });
+  }
+
+  /**
+   * Filter plugins by tags
+   * 
+   * @param plugins - Plugins to filter
+   * @param tags - Tags to match (any)
+   * @returns Filtered plugins
+   */
+  static byTags(plugins: PluginMetadata[], tags: string[]): PluginMetadata[] {
+    return plugins.filter((plugin) => {
+      return tags.some((tag) => plugin.tags.includes(tag));
+    });
+  }
+
+  /**
+   * Filter plugins by author
+   * 
+   * @param plugins - Plugins to filter
+   * @param author - Author name
+   * @returns Filtered plugins
+   */
+  static byAuthor(plugins: PluginMetadata[], author: string): PluginMetadata[] {
+    return plugins.filter((plugin) => plugin.author === author);
+  }
+
+  /**
+   * Filter plugins that support async
+   * 
+   * @param plugins - Plugins to filter
+   * @returns Filtered plugins
+   */
+  static asyncOnly(plugins: PluginMetadata[]): PluginMetadata[] {
+    return plugins.filter((plugin) => plugin.supports.async);
+  }
+
+  /**
+   * Filter plugins that support parallel execution
+   * 
+   * @param plugins - Plugins to filter
+   * @returns Filtered plugins
+   */
+  static parallelOnly(plugins: PluginMetadata[]): PluginMetadata[] {
+    return plugins.filter((plugin) => plugin.supports.parallel);
+  }
+
+  /**
+   * Apply multiple filters
+   * 
+   * @param plugins - Plugins to filter
+   * @param query - Filter query
+   * @returns Filtered plugins
+   */
+  static apply(plugins: PluginMetadata[], query: PluginQuery): PluginMetadata[] {
+    let result = plugins;
+
+    if (query.keyword) {
+      result = this.byKeyword(result, query.keyword);
+    }
+
+    if (query.category) {
+      result = this.byCategory(result, query.category);
+    }
+
+    if (query.language) {
+      result = this.byLanguage(result, query.language);
+    }
+
+    if (query.tags && query.tags.length > 0) {
+      result = this.byTags(result, query.tags);
+    }
+
+    if (query.author) {
+      result = this.byAuthor(result, query.author);
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Sort plugins by various criteria
+ */
+export class PluginSorter {
+  /**
+   * Sort plugins by name
+   * 
+   * @param plugins - Plugins to sort
+   * @param ascending - Sort order
+   * @returns Sorted plugins
+   */
+  static byName(plugins: PluginMetadata[], ascending = true): PluginMetadata[] {
+    return [...plugins].sort((a, b) => {
+      const result = a.name.localeCompare(b.name);
+      return ascending ? result : -result;
+    });
+  }
+
+  /**
+   * Sort plugins by registration date
+   * 
+   * @param plugins - Plugins to sort
+   * @param ascending - Sort order
+   * @returns Sorted plugins
+   */
+  static byDate(plugins: PluginMetadata[], ascending = true): PluginMetadata[] {
+    return [...plugins].sort((a, b) => {
+      const dateA = a.registeredAt?.getTime() || 0;
+      const dateB = b.registeredAt?.getTime() || 0;
+      const result = dateA - dateB;
+      return ascending ? result : -result;
+    });
+  }
+
+  /**
+   * Sort plugins by category
+   * 
+   * @param plugins - Plugins to sort
+   * @returns Sorted plugins
+   */
+  static byCategory(plugins: PluginMetadata[]): PluginMetadata[] {
+    const order: PluginCategory[] = [
+      "generator",
+      "transformer",
+      "enhancer",
+      "analyzer",
+      "utility",
+    ];
+    
+    return [...plugins].sort((a, b) => {
+      return order.indexOf(a.category) - order.indexOf(b.category);
+    });
+  }
+}
+
+/**
+ * Plugin discovery helpers
+ */
+export class PluginDiscovery {
+  /**
+   * Find plugins related to a given plugin
+   * 
+   * @param plugins - All plugins
+   * @param pluginId - Plugin to find related plugins for
+   * @returns Related plugins
+   */
+  static findRelated(
+    plugins: PluginMetadata[],
+    pluginId: string
+  ): PluginMetadata[] {
+    const plugin = plugins.find((p) => p.id === pluginId);
+    if (!plugin) {
+      return [];
+    }
+
+    // Find plugins with similar tags
+    return plugins.filter((p) => {
+      if (p.id === pluginId) {
+        return false;
+      }
+      
+      const sharedTags = plugin.tags.filter((tag) => p.tags.includes(tag));
+      return sharedTags.length > 0;
+    });
+  }
+
+  /**
+   * Find plugins that depend on a given plugin
+   * 
+   * @param plugins - All plugins
+   * @param allExtensions - Map of extensions (for dependency info)
+   * @param pluginId - Plugin to find dependents for
+   * @returns Dependent plugins
+   */
+  static findDependents(
+    plugins: PluginMetadata[],
+    allExtensions: Map<string, { dependencies?: string[] }>,
+    pluginId: string
+  ): PluginMetadata[] {
+    return plugins.filter((p) => {
+      const ext = allExtensions.get(p.id);
+      return ext?.dependencies?.includes(pluginId);
+    });
+  }
+
+  /**
+   * Find missing dependencies for plugins
+   * 
+   * @param plugins - Plugins to check
+   * @param allExtensions - Map of all extensions
+   * @returns Map of plugin ID to missing dependencies
+   */
+  static findMissingDependencies(
+    plugins: PluginMetadata[],
+    allExtensions: Map<string, { dependencies?: string[] }>
+  ): Map<string, string[]> {
+    const missing = new Map<string, string[]>();
+    const availableIds = new Set(plugins.map((p) => p.id));
+
+    for (const plugin of plugins) {
+      const ext = allExtensions.get(plugin.id);
+      if (ext?.dependencies) {
+        const missingDeps = ext.dependencies.filter(
+          (dep) => !availableIds.has(dep)
+        );
+        if (missingDeps.length > 0) {
+          missing.set(plugin.id, missingDeps);
+        }
+      }
+    }
+
+    return missing;
+  }
+
+  /**
+   * Suggest plugins based on a user's current plugins
+   * 
+   * @param currentPlugins - Currently used plugins
+   * @param allPlugins - All available plugins
+   * @returns Suggested plugins
+   */
+  static suggestPlugins(
+    currentPlugins: PluginMetadata[],
+    allPlugins: PluginMetadata[]
+  ): PluginMetadata[] {
+    if (currentPlugins.length === 0) {
+      return [];
+    }
+
+    // Collect all tags from current plugins
+    const currentTags = new Set<string>();
+    for (const plugin of currentPlugins) {
+      plugin.tags.forEach((tag) => currentTags.add(tag));
+    }
+
+    // Find plugins with similar tags that aren't already used
+    const currentIds = new Set(currentPlugins.map((p) => p.id));
+    const suggestions = allPlugins.filter((plugin) => {
+      if (currentIds.has(plugin.id)) {
+        return false;
+      }
+      
+      const matchingTags = plugin.tags.filter((tag) => currentTags.has(tag));
+      return matchingTags.length > 0;
+    });
+
+    // Sort by number of matching tags
+    return suggestions.sort((a, b) => {
+      const aMatches = a.tags.filter((tag) => currentTags.has(tag)).length;
+      const bMatches = b.tags.filter((tag) => currentTags.has(tag)).length;
+      return bMatches - aMatches;
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,50 @@
+/**
+ * GLOST Plugin Registry
+ * 
+ * Enhanced plugin registry with discovery, metadata, and validation.
+ * 
+ * @packageDocumentation
+ * 
+ * @example
+ * ```typescript
+ * import { pluginRegistry } from "glost-registry";
+ * 
+ * // Register a plugin
+ * pluginRegistry.register(myExtension, {
+ *   version: "1.0.0",
+ *   description: "My awesome plugin",
+ *   category: "enhancer",
+ *   tags: ["transcription"],
+ *   supports: {
+ *     languages: ["th", "ja"],
+ *     async: true
+ *   }
+ * });
+ * 
+ * // Search for plugins
+ * const plugins = pluginRegistry.search({ language: "th" });
+ * 
+ * // Check for conflicts
+ * const report = pluginRegistry.checkConflicts(["plugin1", "plugin2"]);
+ * ```
+ */
+
+export { PluginRegistry, pluginRegistry } from "./registry.js";
+export { PluginFilter, PluginSorter, PluginDiscovery } from "./discovery.js";
+export { PluginValidator } from "./validation.js";
+export type {
+  PluginMetadata,
+  PluginCategory,
+  PluginCapabilities,
+  PluginRequirements,
+  PluginOptionsSchema,
+  PropertySchema,
+  PluginExample,
+  PluginQuery,
+  ConflictReport,
+  PluginConflict,
+  ValidationResult,
+  ValidationError,
+  ValidationWarning,
+  RegistryStatistics,
+} from "./types.js";