kist 0.1.45 → 0.1.58

package/js/core/plugin/PluginManager.js

@@ -0,0 +1,288 @@
+"use strict";
+// ============================================================================
+// Import
+// ============================================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginManager = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const AbstractProcess_1 = require("../abstract/AbstractProcess");
+// ============================================================================
+// Class
+// ============================================================================
+/**
+ * PluginManager handles discovery, loading, and lifecycle of kist plugins.
+ * Supports both npm-installed plugins (@getkist/plugin-*) and local plugins.
+ */
+class PluginManager extends AbstractProcess_1.AbstractProcess {
+    // Constructor
+    // ========================================================================
+    constructor() {
+        super();
+        this.loadedPlugins = new Map();
+        this.pluginActions = new Map();
+        this.logInfo("PluginManager initialized.");
+    }
+    // Singleton Methods
+    // ========================================================================
+    static getInstance() {
+        if (!PluginManager.instance) {
+            PluginManager.instance = new PluginManager();
+        }
+        return PluginManager.instance;
+    }
+    static resetInstance() {
+        PluginManager.instance = null;
+    }
+    // Plugin Discovery
+    // ========================================================================
+    /**
+     * Discovers and loads all available plugins from:
+     * - node_modules/@getkist/plugin-*
+     * - node_modules/kist-plugin-*
+     * - Local plugins directory (if configured)
+     */
+    discoverPlugins(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logInfo("Starting plugin discovery...");
+            const prefixes = (options === null || options === void 0 ? void 0 : options.pluginPrefixes) || [
+                "@getkist/action-",
+                "kist-plugin-",
+            ];
+            // Discover npm plugins
+            yield this.discoverNpmPlugins(prefixes);
+            // Discover local plugins if path provided
+            if (options === null || options === void 0 ? void 0 : options.localPluginsPath) {
+                yield this.discoverLocalPlugins(options.localPluginsPath);
+            }
+            this.logInfo(`Plugin discovery complete. Loaded ${this.loadedPlugins.size} plugins.`);
+        });
+    }
+    /**
+     * Discovers plugins installed via npm with specified prefixes
+     */
+    discoverNpmPlugins(prefixes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeModulesPath = (0, path_1.join)(process.cwd(), "node_modules");
+            try {
+                const directories = (0, fs_1.readdirSync)(nodeModulesPath, {
+                    withFileTypes: true,
+                });
+                for (const dir of directories) {
+                    // Check for scoped packages (@getkist/plugin-*)
+                    if (dir.isDirectory() && dir.name.startsWith("@")) {
+                        yield this.discoverScopedPlugins((0, path_1.join)(nodeModulesPath, dir.name), prefixes);
+                    }
+                    // Check for non-scoped packages (kist-plugin-*)
+                    for (const prefix of prefixes) {
+                        if (dir.isDirectory() &&
+                            !prefix.startsWith("@") &&
+                            dir.name.startsWith(prefix)) {
+                            yield this.loadPlugin((0, path_1.join)(nodeModulesPath, dir.name), dir.name);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logError("Failed to discover npm plugins.", error);
+            }
+        });
+    }
+    /**
+     * Discovers plugins in scoped packages (@getkist/*)
+     */
+    discoverScopedPlugins(scopePath, prefixes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const packages = (0, fs_1.readdirSync)(scopePath, { withFileTypes: true });
+                for (const pkg of packages) {
+                    for (const prefix of prefixes) {
+                        const scopePrefix = prefix.split("/")[1]; // Extract "plugin-" from "@getkist/plugin-"
+                        if (pkg.isDirectory() &&
+                            scopePrefix &&
+                            pkg.name.startsWith(scopePrefix)) {
+                            const fullName = `${scopePath.split("/").pop()}/${pkg.name}`;
+                            yield this.loadPlugin((0, path_1.join)(scopePath, pkg.name), fullName);
+                        }
+                    }
+                }
+            }
+            catch (_error) {
+                this.logDebug(`No scoped plugins found in ${scopePath}`);
+            }
+        });
+    }
+    /**
+     * Discovers plugins from a local directory
+     */
+    discoverLocalPlugins(localPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const pluginPath = (0, path_1.join)(process.cwd(), localPath);
+                const directories = (0, fs_1.readdirSync)(pluginPath, {
+                    withFileTypes: true,
+                });
+                for (const dir of directories) {
+                    if (dir.isDirectory()) {
+                        yield this.loadPlugin((0, path_1.join)(pluginPath, dir.name), `local:${dir.name}`);
+                    }
+                }
+            }
+            catch (_error) {
+                this.logDebug(`No local plugins found at ${localPath}`);
+            }
+        });
+    }
+    // Plugin Loading
+    // ========================================================================
+    /**
+     * Loads a single plugin from the specified path
+     */
+    loadPlugin(pluginPath, pluginName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logDebug(`Loading plugin: ${pluginName}`);
+                const pluginModule = yield Promise.resolve(`${pluginPath}`).then(s => __importStar(require(s)));
+                const plugin = pluginModule.default || pluginModule;
+                if (!plugin || typeof plugin.registerActions !== "function") {
+                    this.logWarn(`Plugin ${pluginName} does not implement ActionPlugin interface.`);
+                    return;
+                }
+                // Get plugin metadata if available
+                const metadata = {
+                    name: pluginName,
+                    version: typeof plugin.version === "string"
+                        ? plugin.version
+                        : "unknown",
+                    description: typeof plugin.description === "string"
+                        ? plugin.description
+                        : undefined,
+                    actions: [],
+                };
+                // Register actions from the plugin
+                const actions = plugin.registerActions();
+                for (const [actionName, actionClass] of Object.entries(actions)) {
+                    this.pluginActions.set(actionName, actionClass);
+                    metadata.actions.push(actionName);
+                    this.logDebug(`  - Registered action: ${actionName}`);
+                }
+                this.loadedPlugins.set(pluginName, metadata);
+                this.logInfo(`Plugin "${pluginName}" loaded successfully with ${metadata.actions.length} actions.`);
+            }
+            catch (error) {
+                this.logError(`Failed to load plugin ${pluginName}:`, error);
+            }
+        });
+    }
+    /**
+     * Manually register a plugin programmatically
+     */
+    registerPlugin(plugin, name) {
+        this.logInfo(`Manually registering plugin: ${name}`);
+        const metadata = {
+            name,
+            version: typeof plugin.version === "string"
+                ? plugin.version
+                : "unknown",
+            description: typeof plugin.description === "string"
+                ? plugin.description
+                : undefined,
+            actions: [],
+        };
+        const actions = plugin.registerActions();
+        for (const [actionName, actionClass] of Object.entries(actions)) {
+            this.pluginActions.set(actionName, actionClass);
+            metadata.actions.push(actionName);
+        }
+        this.loadedPlugins.set(name, metadata);
+        this.logInfo(`Plugin "${name}" registered with ${metadata.actions.length} actions.`);
+    }
+    // Plugin Queries
+    // ========================================================================
+    /**
+     * Gets all actions from loaded plugins
+     */
+    getPluginActions() {
+        return new Map(this.pluginActions);
+    }
+    /**
+     * Gets metadata for all loaded plugins
+     */
+    getLoadedPlugins() {
+        return Array.from(this.loadedPlugins.values());
+    }
+    /**
+     * Gets metadata for a specific plugin
+     */
+    getPluginMetadata(name) {
+        return this.loadedPlugins.get(name);
+    }
+    /**
+     * Checks if a specific plugin is loaded
+     */
+    isPluginLoaded(name) {
+        return this.loadedPlugins.has(name);
+    }
+    /**
+     * Lists all action names from plugins
+     */
+    listPluginActions() {
+        return Array.from(this.pluginActions.keys());
+    }
+    // Cleanup
+    // ========================================================================
+    /**
+     * Clears all loaded plugins and their actions
+     */
+    clearPlugins() {
+        this.loadedPlugins.clear();
+        this.pluginActions.clear();
+        this.logInfo("All plugins cleared.");
+    }
+}
+exports.PluginManager = PluginManager;
+// Parameters
+// ========================================================================
+PluginManager.instance = null;

package/js/index.d.ts

@@ -1,3 +1,10 @@
 export { Kist } from "./kist";
 export * from "./types";
 export * from "./cli.js";
+export { ActionInterface } from "./interface/ActionInterface";
+export { ActionPlugin } from "./interface/ActionPlugin";
+export { PluginMetadata } from "./interface/PluginMetadata";
+export { PluginManager } from "./core/plugin/PluginManager";
+export { Action } from "./core/pipeline/Action";
+export { ActionRegistry } from "./core/pipeline/ActionRegistry";
+export { CORE_ACTIONS, PLUGIN_ACTIONS, PLUGIN_PACKAGES, type CoreActionName, type PluginActionName, } from "./config/actions.config";

package/js/index.js

@@ -17,7 +17,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Kist = void 0;
+exports.PLUGIN_PACKAGES = exports.PLUGIN_ACTIONS = exports.CORE_ACTIONS = exports.ActionRegistry = exports.Action = exports.PluginManager = exports.Kist = void 0;
 // Core Modules
 // export { Pipeline } from "./core/Pipeline";
 // export { ConfigLoader } from "./core/ConfigLoader";
@@ -34,3 +34,16 @@ Object.defineProperty(exports, "Kist", { enumerable: true, get: function () { re
 __exportStar(require("./types"), exports);
 // CLI Functions (if required programmatically)
 __exportStar(require("./cli.js"), exports);
+// Plugin management
+var PluginManager_1 = require("./core/plugin/PluginManager");
+Object.defineProperty(exports, "PluginManager", { enumerable: true, get: function () { return PluginManager_1.PluginManager; } });
+// Action system
+var Action_1 = require("./core/pipeline/Action");
+Object.defineProperty(exports, "Action", { enumerable: true, get: function () { return Action_1.Action; } });
+var ActionRegistry_1 = require("./core/pipeline/ActionRegistry");
+Object.defineProperty(exports, "ActionRegistry", { enumerable: true, get: function () { return ActionRegistry_1.ActionRegistry; } });
+// Configuration for plugin developers
+var actions_config_1 = require("./config/actions.config");
+Object.defineProperty(exports, "CORE_ACTIONS", { enumerable: true, get: function () { return actions_config_1.CORE_ACTIONS; } });
+Object.defineProperty(exports, "PLUGIN_ACTIONS", { enumerable: true, get: function () { return actions_config_1.PLUGIN_ACTIONS; } });
+Object.defineProperty(exports, "PLUGIN_PACKAGES", { enumerable: true, get: function () { return actions_config_1.PLUGIN_PACKAGES; } });

package/js/interface/ActionPlugin.d.ts

@@ -1,4 +1,47 @@
 import { ActionInterface } from "./ActionInterface";
+/**
+ * ActionPlugin defines the contract for kist plugins.
+ * Plugins can provide one or more actions to extend kist's functionality.
+ *
+ * Example plugin structure:
+ * ```typescript
+ * import { ActionPlugin, ActionInterface } from 'kist';
+ *
+ * export default {
+ *   version: '1.0.0',
+ *   description: 'My custom kist plugin',
+ *   registerActions() {
+ *     return {
+ *       'MyCustomAction': MyCustomAction
+ *     };
+ *   }
+ * } as ActionPlugin;
+ * ```
+ */
 export interface ActionPlugin {
+    /**
+     * Returns a record of action classes provided by this plugin.
+     * Keys are action names, values are action class constructors.
+     */
     registerActions(): Record<string, new () => ActionInterface>;
+    /**
+     * Optional: Plugin version (semantic versioning recommended)
+     */
+    version?: string;
+    /**
+     * Optional: Plugin description
+     */
+    description?: string;
+    /**
+     * Optional: Plugin author information
+     */
+    author?: string;
+    /**
+     * Optional: Plugin repository URL
+     */
+    repository?: string;
+    /**
+     * Optional: Keywords for plugin discoverability
+     */
+    keywords?: string[];
 }

package/js/interface/PluginMetadata.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Metadata for a loaded plugin
+ */
+export interface PluginMetadata {
+    /**
+     * The unique name of the plugin
+     */
+    name: string;
+    /**
+     * The version of the plugin
+     */
+    version: string;
+    /**
+     * Optional description of the plugin
+     */
+    description?: string;
+    /**
+     * List of action names provided by this plugin
+     */
+    actions: string[];
+    /**
+     * Optional author information
+     */
+    author?: string;
+    /**
+     * Optional repository URL
+     */
+    repository?: string;
+    /**
+     * Optional keywords for discoverability
+     */
+    keywords?: string[];
+}

package/js/interface/PluginMetadata.js

@@ -0,0 +1,5 @@
+"use strict";
+// ============================================================================
+// Interface
+// ============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });

package/js/kist.js

@@ -17,6 +17,7 @@ const AbstractProcess_1 = require("./core/abstract/AbstractProcess");
 const ConfigStore_1 = require("./core/config/ConfigStore");
 const ActionRegistry_1 = require("./core/pipeline/ActionRegistry");
 const PipelineManager_1 = require("./core/pipeline/PipelineManager");
+const PluginManager_1 = require("./core/plugin/PluginManager");
 const LiveServer_1 = require("./live/LiveServer");
 const LiveWatcher_1 = require("./live/LiveWatcher");
 // ============================================================================
@@ -56,7 +57,7 @@ class Kist extends AbstractProcess_1.AbstractProcess {
             this.logInfo("Starting Kist workflow...");
             try {
                 // Initialize the ActionRegistry with available actions
-                this.initializeActionRegistry();
+                yield this.initializeActionRegistry();
                 // Create and run the PipelineManager
                 const liveReloadEnabled = ConfigStore_1.ConfigStore.getInstance().get("options.live.enabled");
                 const liveReloadServer = liveReloadEnabled
@@ -79,9 +80,29 @@ class Kist extends AbstractProcess_1.AbstractProcess {
      * Automatically registers core actions and discovers external plugins.
      */
     initializeActionRegistry() {
-        this.logInfo("Initializing ActionRegistry...");
-        ActionRegistry_1.ActionRegistry.initialize();
-        this.logInfo("ActionRegistry initialized successfully.");
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logInfo("Initializing plugin system...");
+            // Initialize and discover plugins first
+            const pluginManager = PluginManager_1.PluginManager.getInstance();
+            yield pluginManager.discoverPlugins({
+                pluginPrefixes: ["@getkist/action-", "kist-plugin-"],
+            });
+            // Log loaded plugins
+            const plugins = pluginManager.getLoadedPlugins();
+            if (plugins.length > 0) {
+                this.logInfo(`Loaded ${plugins.length} plugin(s):`);
+                plugins.forEach((plugin) => {
+                    this.logInfo(`  - ${plugin.name} v${plugin.version} (${plugin.actions.length} actions)`);
+                });
+            }
+            else {
+                this.logDebug("No external plugins found.");
+            }
+            // Initialize ActionRegistry (will register core + plugin actions)
+            this.logInfo("Initializing ActionRegistry...");
+            ActionRegistry_1.ActionRegistry.initialize();
+            this.logInfo("ActionRegistry initialized successfully.");
+        });
     }
     /**
      * Sets up live reload functionality.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kist",
-  "version": "0.1.45",
-  "description": "Package Pipeline Processor",
+  "version": "0.1.58",
+  "description": "Lightweight Package Pipeline Processor with Plugin Architecture",
   "keywords": [
     "kist",
     "package",
@@ -11,7 +11,11 @@
     "compile",
     "compiler",
     "framework",
-    "web"
+    "web",
+    "plugin-architecture",
+    "pipeline",
+    "build-tool",
+    "automation"
   ],
   "license": "MIT",
   "homepage": "https://www.getkist.com/",
@@ -53,9 +57,7 @@
       "url": "https://github.com/sponsors/scape-foundation"
     }
   ],
-  "bin": {
-    "kist": "js/cli.js"
-  },
+  "bin": "js/cli.js",
   "dependencies": {
     "@babel/core": "^7.28.3",
     "@babel/preset-env": "^7.28.3",
@@ -76,9 +78,9 @@
     "express-rate-limit": "^8.0.1",
     "fantasticon": "^3.0.0",
     "fs-extra": "^11.3.1",
-    "glob": "^11.0.3",
+    "glob": "^13.0.0",
     "js-yaml": "^4.1.0",
-    "jsdom": "^26.1.0",
+    "jsdom": "^27.2.0",
     "lodash": "^4.17.21",
     "nunjucks": "^3.2.4",
     "postcss": "^8.5.6",
@@ -90,5 +92,11 @@
     "svgo": "^4.0.0",
     "terser": "^5.43.1",
     "ws": "^8.18.3"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/js/index.d.ts",
+      "import": "./dist/js/index.js"
+    }
   }
-}
+}

package/ts/actions/DirectoryCleanAction/DirectoryCleanAction.ts

@@ -87,7 +87,7 @@ export class DirectoryCleanAction extends Action {
                 const stat = await fs.promises.lstat(curPath);
                 if (stat.isDirectory()) {
                     // Recursively clean subdirectory
-                    await fs.promises.rmdir(curPath, { recursive: true });
+                    await fs.promises.rm(curPath, { recursive: true });
                     this.logInfo(`Deleted directory: ${relativePath}`);
                 } else {
                     // Delete file
@@ -105,7 +105,7 @@ export class DirectoryCleanAction extends Action {
      * @returns A string description of the action.
      */
     describe(): string {
-        let description = `
+        const description = `
             Cleans a directory by deleting all its contents while retaining
             files and directories matching specified glob patterns. If the
             directory does not exist, the action will skip gracefully.

package/ts/actions/StyleProcessingAction/postcss.config.expanded.ts

@@ -3,7 +3,6 @@
 // ============================================================================
 
 import autoprefixer from "autoprefixer"; // Automatically adds vendor prefixes to CSS rules
-import cssnano from "cssnano";
 // import postcssSimpleVars from 'postcss-simple-vars'; // Plugin to handle CSS variables
 // import postcssNested from 'postcss-nested'; // Plugin to allow nesting of CSS rules
 // import postcssImport from 'postcss-import'; // Plugin to inline import CSS files into a single CSS

package/ts/actions/SvgPackagerAction/SvgPackagerAction.ts

@@ -5,7 +5,7 @@
 import * as fs from "fs/promises";
 import * as glob from "glob";
 import * as path from "path";
-import SVGO, { loadConfig } from "svgo";
+import { loadConfig, optimize } from "svgo";
 import { Action } from "../../core/pipeline/Action";
 import { ActionOptionsType } from "../../types/ActionOptionsType";
 
@@ -101,7 +101,7 @@ export class SvgPackagerAction extends Action {
         svgContent: string,
     ): Promise<string> {
         const config = await loadConfig(svgoConfigPath);
-        const result = await SVGO.optimize(svgContent, { ...config });
+        const result = await optimize(svgContent, { ...config });
         return result.data.trim();
     }
 

package/ts/actions/TemplateRenderAction/TemplateRenderAction.ts

@@ -84,7 +84,7 @@ export class TemplateRenderAction extends Action {
         template: string,
         outputFile: string,
         context: Record<string, any>,
-        templatesDir: string,
+        _templatesDir: string,
     ): Promise<void> {
         this.logInfo(`Rendering: ${template} → ${outputFile}`);
 

package/ts/actions/VersionWriteAction/VersionWriteAction.ts

@@ -141,7 +141,11 @@ export class VersionWriteAction extends Action {
                 return line;
             });
 
-            await fs.writeFile(filePath, updatedLines.join("\n"), "utf8");
+            await fs.writeFile(
+                filePath,
+                updatedLines.join("\n") + "\n",
+                "utf8",
+            );
             this.logInfo(
                 `Version replaced in file "${filePath}" for key "${key}".`,
             );
@@ -158,7 +162,7 @@ export class VersionWriteAction extends Action {
      * @returns A string description of the action.
      */
     describe(): string {
-        let description = `
+        const description = `
             Replaces a version string in one or more specified files based on
             a key and pattern. Can retrieve the version from package.json or
             set it manually.