@reliverse/rempts-core 1.6.1 → 2.3.2

package/dist/plugin/store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Zustand store utilities for Rempts plugin system
+ */
+import { type StoreApi } from "zustand";
+/**
+ * Generic Zustand store interface for plugins
+ */
+export interface PluginStore<TState = any> extends StoreApi<TState> {
+    /**
+     * Get the current state
+     */
+    getState(): TState;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener: (state: TState, prevState: TState) => void): () => void;
+    /**
+     * Set new state
+     */
+    setState(updater: TState | ((prevState: TState) => TState)): void;
+    /**
+     * Destroy the store
+     */
+    destroy(): void;
+}
+/**
+ * Create a Zustand store for a plugin
+ */
+export declare function createPluginStore<TState>(initialState: TState): PluginStore<TState>;
+/**
+ * Combine multiple plugin stores into a single store
+ */
+export declare function combinePluginStores<TCombined>(stores: Record<string, PluginStore<any>>): PluginStore<TCombined>;
+/**
+ * Type helper for plugin store state
+ */
+export type PluginStoreState<TStore extends PluginStore<any>> = ReturnType<TStore["getState"]>;
+/**
+ * Middleware for logging store changes (useful for debugging)
+ */
+export declare function createLoggingMiddleware<TState>(): (config: any) => (set: any, get: any, api: any) => any;
+/**
+ * Create a store with logging enabled
+ */
+export declare function createPluginStoreWithLogging<TState>(initialState: TState, enableLogging?: boolean): PluginStore<TState>;

package/dist/plugin/store.js

@@ -0,0 +1,60 @@
+import { createStore } from "zustand";
+export function createPluginStore(initialState) {
+  const store = createStore()(() => initialState);
+  return {
+    ...store,
+    destroy: () => {
+    }
+  };
+}
+export function combinePluginStores(stores) {
+  const initialState = Object.keys(stores).reduce((acc, key) => {
+    const store = stores[key];
+    if (store) {
+      acc[key] = store.getState();
+    }
+    return acc;
+  }, {});
+  const combinedStore = createStore()(() => initialState);
+  const unsubscribers = Object.keys(stores).map((key) => {
+    const store = stores[key];
+    if (store) {
+      return store.subscribe((state) => {
+        combinedStore.setState((prevState) => ({
+          ...prevState,
+          [key]: state
+        }));
+      });
+    }
+    return () => {
+    };
+  });
+  return {
+    ...combinedStore,
+    destroy: () => {
+      unsubscribers.forEach((unsubscribe) => unsubscribe());
+    }
+  };
+}
+export function createLoggingMiddleware() {
+  return (config) => (set, get, api) => config(
+    (...args) => {
+      console.log("Store before:", get());
+      set(...args);
+      console.log("Store after:", get());
+    },
+    get,
+    api
+  );
+}
+export function createPluginStoreWithLogging(initialState, enableLogging = false) {
+  if (enableLogging) {
+    const store = createStore()(createLoggingMiddleware()(() => initialState));
+    return {
+      ...store,
+      destroy: () => {
+      }
+    };
+  }
+  return createPluginStore(initialState);
+}

package/dist/plugin/testing.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Plugin testing utilities for Rempts
+ */
+import type { RemptsConfig } from "../types.js";
+import { type PluginStore } from "./store.js.js";
+import type { CommandContext, Plugin, PluginContext } from "./types.js";
+/**
+ * Mock plugin context for testing
+ */
+export declare function createMockPluginContext(config?: Partial<RemptsConfig>, store?: PluginStore<any>): PluginContext;
+/**
+ * Mock command context for testing
+ */
+export declare function createMockCommandContext<TStore = {}>(command?: string, args?: string[], flags?: Record<string, any>, initialStore?: TStore): CommandContext<TStore>;
+/**
+ * Test plugin lifecycle hooks
+ */
+export declare function testPluginHooks<TStore = {}>(plugin: Plugin<TStore>, options?: {
+    config?: Partial<RemptsConfig>;
+    store?: TStore;
+    command?: string;
+    args?: string[];
+    flags?: Record<string, any>;
+}): Promise<{
+    setup?: any;
+    configResolved?: any;
+    beforeCommand?: any;
+    afterCommand?: any;
+}>;
+/**
+ * Assert plugin behavior in tests
+ */
+export declare function assertPluginBehavior(results: Awaited<ReturnType<typeof testPluginHooks>>, expectations: {
+    setupShouldSucceed?: boolean;
+    configResolvedShouldSucceed?: boolean;
+    beforeCommandShouldSucceed?: boolean;
+    afterCommandShouldSucceed?: boolean;
+}): void;

package/dist/plugin/testing.js

@@ -0,0 +1,175 @@
+import { createLogger } from "../utils/logger.js";
+import { createPluginStore } from "./store.js";
+export function createMockPluginContext(config = {}, store = createPluginStore({})) {
+  return {
+    config,
+    updateConfig: () => {
+    },
+    registerCommand: () => {
+    },
+    use: () => {
+    },
+    store,
+    logger: createLogger("test"),
+    paths: {
+      cwd: process.cwd(),
+      home: process.env.HOME || "/tmp",
+      config: "/tmp/.config/rempts"
+    }
+  };
+}
+export function createMockCommandContext(command = "test", args = [], flags = {}, initialStore = {}) {
+  let storeState = { ...initialStore };
+  const mockStore = {
+    getState: () => storeState,
+    setState: (updater) => {
+      if (typeof updater === "function") {
+        storeState = { ...storeState, ...updater(storeState) };
+      } else {
+        storeState = { ...storeState, ...updater };
+      }
+    },
+    subscribe: () => () => {
+    },
+    // Mock subscription
+    destroy: () => {
+    }
+  };
+  return {
+    command,
+    commandDef: {},
+    args,
+    flags,
+    env: {
+      isCI: false,
+      isAIAgent: false,
+      aiAgents: []
+    },
+    store: mockStore,
+    getStoreValue: (key) => storeState[key],
+    setStoreValue: (key, value) => {
+      mockStore.setState({ [key]: value });
+    },
+    hasStoreValue: (key) => key in storeState
+  };
+}
+export async function testPluginHooks(plugin, options = {}) {
+  const hooks = plugin();
+  const results = {};
+  if (hooks.setup) {
+    const context = createMockPluginContext(options.config);
+    try {
+      await hooks.setup(context);
+      results.setup = { success: true, context };
+    } catch (error) {
+      results.setup = { success: false, error };
+    }
+  }
+  if (hooks.configResolved) {
+    const config = {
+      name: "test-cli",
+      version: "1.0.0",
+      description: "Test CLI",
+      commands: {},
+      build: {
+        targets: ["native"],
+        compress: false,
+        minify: false,
+        sourcemap: true
+      },
+      dev: {
+        watch: true,
+        inspect: false
+      },
+      test: {
+        pattern: ["**/*.test.ts", "**/*.spec.ts"],
+        coverage: false,
+        watch: false
+      },
+      workspace: {
+        versionStrategy: "fixed"
+      },
+      release: {
+        npm: true,
+        github: false,
+        tagFormat: "v{{version}}",
+        conventionalCommits: true
+      },
+      plugins: []
+    };
+    try {
+      await hooks.configResolved(config);
+      results.configResolved = { success: true, config };
+    } catch (error) {
+      results.configResolved = { success: false, error };
+    }
+  }
+  if (hooks.beforeCommand) {
+    const context = createMockCommandContext(
+      options.command || "test",
+      options.args || [],
+      options.flags || {},
+      options.store || {}
+    );
+    try {
+      await hooks.beforeCommand(context);
+      results.beforeCommand = { success: true, context };
+    } catch (error) {
+      results.beforeCommand = { success: false, error };
+    }
+  }
+  if (hooks.afterCommand) {
+    const context = createMockCommandContext(
+      options.command || "test",
+      options.args || [],
+      options.flags || {},
+      options.store || {}
+    );
+    try {
+      await hooks.afterCommand(context);
+      results.afterCommand = { success: true, context };
+    } catch (error) {
+      results.afterCommand = { success: false, error };
+    }
+  }
+  return results;
+}
+export function assertPluginBehavior(results, expectations) {
+  const assertions = [];
+  if (expectations.setupShouldSucceed !== void 0) {
+    const actual = results.setup?.success ?? false;
+    if (actual !== expectations.setupShouldSucceed) {
+      assertions.push(
+        `Setup hook ${actual ? "succeeded" : "failed"} but expected ${expectations.setupShouldSucceed ? "success" : "failure"}`
+      );
+    }
+  }
+  if (expectations.configResolvedShouldSucceed !== void 0) {
+    const actual = results.configResolved?.success ?? false;
+    if (actual !== expectations.configResolvedShouldSucceed) {
+      assertions.push(
+        `ConfigResolved hook ${actual ? "succeeded" : "failed"} but expected ${expectations.configResolvedShouldSucceed ? "success" : "failure"}`
+      );
+    }
+  }
+  if (expectations.beforeCommandShouldSucceed !== void 0) {
+    const actual = results.beforeCommand?.success ?? false;
+    if (actual !== expectations.beforeCommandShouldSucceed) {
+      assertions.push(
+        `BeforeCommand hook ${actual ? "succeeded" : "failed"} but expected ${expectations.beforeCommandShouldSucceed ? "success" : "failure"}`
+      );
+    }
+  }
+  if (expectations.afterCommandShouldSucceed !== void 0) {
+    const actual = results.afterCommand?.success ?? false;
+    if (actual !== expectations.afterCommandShouldSucceed) {
+      assertions.push(
+        `AfterCommand hook ${actual ? "succeeded" : "failed"} but expected ${expectations.afterCommandShouldSucceed ? "success" : "failure"}`
+      );
+    }
+  }
+  if (assertions.length > 0) {
+    throw new Error(`Plugin behavior assertions failed:
+${assertions.join("\n")}`);
+  }
+}

package/dist/plugin/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Core plugin types and interfaces for Rempts
+ */
+import type { Command, RemptsConfig, ResolvedConfig } from "../types.js";
+import type { Logger } from "../utils/logger.js";
+import type { PluginStore } from "./store.js";
+export type CommandDefinition = Command<any>;
+/**
+ * Functional plugin hooks with store type
+ */
+export interface PluginHooks<TStore = {}> {
+    /** Plugin store - Zustand store instance */
+    store?: PluginStore<TStore>;
+    /**
+     * Setup hook - Called during CLI initialization
+     * Can modify configuration and register commands
+     */
+    setup?: (context: PluginContext) => void | Promise<void>;
+    /**
+     * Config resolved hook - Called after all configuration is finalized
+     * Config is now immutable
+     */
+    configResolved?: (config: ResolvedConfig) => void | Promise<void>;
+    /**
+     * Before command hook - Called before command execution
+     * Can inject context and validate
+     * Uses generic constraints to preserve store type information
+     */
+    beforeCommand?: (context: CommandContext<any>) => void | Promise<void>;
+    /**
+     * After command hook - Called after command execution
+     * Receives result or error from command
+     * Uses generic constraints to preserve store type information
+     */
+    afterCommand?: (context: CommandContext<any> & CommandResult) => void | Promise<void>;
+}
+/**
+ * Core plugin function that returns hooks
+ */
+export type Plugin<TStore = {}> = () => PluginHooks<TStore>;
+/**
+ * Extract store type from plugin hooks
+ */
+export type StoreOf<P> = P extends PluginHooks<infer S> ? S : {};
+/**
+ * Merge multiple plugin stores into one type
+ */
+export type MergeStores<Plugins extends readonly PluginHooks[]> = Plugins extends readonly [] ? {} : Plugins extends readonly [infer First, ...infer Rest] ? First extends PluginHooks ? Rest extends readonly PluginHooks[] ? StoreOf<First> & MergeStores<Rest> : StoreOf<First> : {} : {};
+/**
+ * Merge stores from plugin functions
+ */
+export type MergePluginStores<Plugins extends readonly Plugin[]> = Plugins extends readonly [] ? {} : Plugins extends readonly [infer First, ...infer Rest] ? First extends Plugin<infer S> ? Rest extends readonly Plugin[] ? S & MergePluginStores<Rest> : S : {} : {};
+/**
+ * Plugin factory function type - returns a function that creates hooks
+ */
+export type PluginFactory<TOptions = any, TStore = {}> = (options?: TOptions) => Plugin<TStore>;
+/**
+ * Command execution result
+ */
+export interface CommandResult {
+    /** Command return value */
+    result?: any;
+    /** Error if command failed */
+    error?: Error;
+    /** Exit code */
+    exitCode?: number;
+}
+/**
+ * Plugin configuration types
+ */
+export type PluginConfig = string | Plugin | PluginFactory | [PluginFactory, any];
+/**
+ * Plugin context available during setup
+ */
+export interface PluginContext {
+    /** Current configuration (being built) */
+    readonly config: Partial<RemptsConfig>;
+    /** Update configuration */
+    updateConfig(partial: Partial<RemptsConfig>): void;
+    /** Register a new command */
+    registerCommand(command: CommandDefinition): void;
+    /** Add global middleware */
+    use(middleware: Middleware): void;
+    /** Shared storage between plugins */
+    readonly store: PluginStore<any>;
+    /** Plugin logger */
+    readonly logger: Logger;
+    /** System paths */
+    readonly paths: PathInfo;
+}
+/**
+ * Command execution context
+ */
+export interface CommandContext<TStore = {}> {
+    /** Command name being executed */
+    readonly command: string;
+    /** The Command object being executed */
+    readonly commandDef: Command<any, TStore>;
+    /** Positional arguments */
+    readonly args: string[];
+    /** Parsed flags/options */
+    readonly flags: Record<string, any>;
+    /** Environment information */
+    readonly env: EnvironmentInfo;
+    /** Type-safe context store */
+    readonly store?: PluginStore<TStore>;
+    /** Type-safe store value access */
+    getStoreValue<K extends keyof TStore>(key: K): TStore[K];
+    getStoreValue(key: string | number | symbol): any;
+    /** Type-safe store value update */
+    setStoreValue<K extends keyof TStore>(key: K, value: TStore[K]): void;
+    setStoreValue(key: string | number | symbol, value: any): void;
+    /** Check if a store property exists */
+    hasStoreValue<K extends keyof TStore>(key: K): boolean;
+    hasStoreValue(key: string | number | symbol): boolean;
+}
+/**
+ * System path information
+ */
+export interface PathInfo {
+    /** Current working directory */
+    cwd: string;
+    /** User home directory */
+    home: string;
+    /** Config directory path */
+    config: string;
+}
+/**
+ * Environment information
+ */
+export interface EnvironmentInfo {
+    /** Running in CI environment */
+    isCI: boolean;
+    /** Additional properties that plugins can add */
+    [key: string]: any;
+}
+/**
+ * Middleware function type
+ */
+export type Middleware = (context: CommandContext, next: () => Promise<any>) => Promise<any>;
+/**
+ * Plugin extension interfaces
+ *
+ * Note: Plugins should extend these interfaces directly in their own code
+ * rather than using module augmentation, as that creates circular dependencies.
+ */

package/dist/tui/registry.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TUI Registry - manages the global TUI renderer
+ * This module provides a simple registry for TUI renderers
+ */
+import type { RenderArgs } from "../types.js";
+export declare function registerTuiRenderer<TFlags = Record<string, unknown>, TStore = {}>(fn: (args: RenderArgs<TFlags, TStore>) => Promise<unknown> | unknown): void;
+export declare function getTuiRenderer<TFlags = Record<string, unknown>, TStore = {}>(): ((args: RenderArgs<TFlags, TStore>) => Promise<unknown> | unknown) | null;
+export declare function clearTuiRenderer(): void;

package/dist/tui/registry.js

@@ -0,0 +1,10 @@
+let renderer = null;
+export function registerTuiRenderer(fn) {
+  renderer = fn;
+}
+export function getTuiRenderer() {
+  return renderer;
+}
+export function clearTuiRenderer() {
+  renderer = null;
+}

package/dist/tui/types.d.ts

@@ -0,0 +1,58 @@
+import type { RenderResult } from "../types.js";
+/**
+ * Options passed to the TUI renderer when rendering a component
+ */
+export interface TuiRendererOptions {
+    /**
+     * Exit on Ctrl+C (default: true)
+     */
+    exitOnCtrlC?: boolean;
+    /**
+     * Target frames per second (default: 30)
+     */
+    targetFps?: number;
+    /**
+     * Enable mouse movement events (default: true)
+     */
+    enableMouseMovement?: boolean;
+    /**
+     * Additional renderer-specific options
+     */
+    [key: string]: unknown;
+}
+/**
+ * Context passed when rendering TUI components
+ */
+export interface TuiRenderContext {
+    /**
+     * Renderer-specific options
+     */
+    rendererOptions?: TuiRendererOptions;
+}
+/**
+ * TUI Renderer interface
+ * Implementations should handle rendering React components to the terminal
+ */
+export interface TuiRenderer {
+    /**
+     * Render a component result to the terminal
+     * @param component The component or render result to render
+     * @param context Rendering context and options
+     * @returns Promise that resolves when rendering completes
+     */
+    render(component: RenderResult, context: TuiRenderContext): Promise<unknown>;
+}
+/**
+ * Register a TUI renderer globally
+ * @param renderer The renderer implementation
+ */
+export declare function registerTuiRenderer(renderer: TuiRenderer): void;
+/**
+ * Get the currently registered TUI renderer
+ * @returns The registered renderer, or null if none registered
+ */
+export declare function getTuiRenderer(): TuiRenderer | null;
+/**
+ * Clear the registered TUI renderer (mainly for testing)
+ */
+export declare function clearTuiRenderer(): void;

package/dist/tui/types.js

@@ -0,0 +1,10 @@
+let globalRenderer = null;
+export function registerTuiRenderer(renderer) {
+  globalRenderer = renderer;
+}
+export function getTuiRenderer() {
+  return globalRenderer;
+}
+export function clearTuiRenderer() {
+  globalRenderer = null;
+}