@reliverse/rempts-core 1.6.1 → 2.3.1

package/dist/types.d.ts

@@ -0,0 +1,178 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { GLOBAL_FLAGS } from "./global-flags.js";
+export type { StandardSchemaV1 } from "@standard-schema/spec";
+export type RenderResult = unknown;
+export interface TuiRenderOptions {
+    exitOnCtrlC?: boolean;
+    targetFps?: number;
+    enableMouseMovement?: boolean;
+    [key: string]: unknown;
+}
+export interface RenderArgs<TFlags = Record<string, unknown>, TStore = {}> extends HandlerArgs<TFlags, TStore> {
+    command: Command<any, TStore>;
+    rendererOptions?: TuiRenderOptions;
+}
+export type RenderFunction<TFlags = Record<string, unknown>, TStore = {}> = (args: RenderArgs<TFlags, TStore>) => RenderResult;
+/**
+ * CLI instance with plugin type information
+ */
+export interface CLI<TStore = {}> {
+    /**
+     * Initialize the CLI (load config, etc)
+     */
+    init(): Promise<void>;
+    /**
+     * Run the CLI with given arguments
+     */
+    run(argv?: string[]): Promise<void>;
+    /**
+     * Execute a command programmatically
+     */
+    execute(commandName: string, args?: string[]): Promise<void>;
+    execute<T extends keyof RegisteredCommands>(commandName: T, options: CommandOptions<T>): Promise<void>;
+    execute<T extends keyof RegisteredCommands>(commandName: T, args: string[], options: CommandOptions<T>): Promise<void>;
+    /**
+     * Add a global before hook that runs before command execution
+     * This provides a simple API for setup/initialization tasks
+     */
+    before(hook: BeforeHook<TStore>): void;
+    /**
+     * Add a global after hook that runs after command execution
+     */
+    after(hook: AfterHook<TStore>): void;
+}
+interface BaseCommand<TOptions extends Options = Options, TStore = {}, TName extends string = string> {
+    description: string;
+    options?: TOptions;
+    alias?: string | string[];
+    handler?: Handler<InferOptions<TOptions>, TStore, TName>;
+    render?: RenderFunction<InferOptions<TOptions>, TStore>;
+}
+export type Command<TOptions extends Options = Options, TStore = {}, TName extends string = string> = (BaseCommand<TOptions, TStore, TName> & {
+    handler: Handler<InferOptions<TOptions>, TStore, TName>;
+}) | (BaseCommand<TOptions, TStore, TName> & {
+    render: RenderFunction<InferOptions<TOptions>, TStore>;
+}) | (BaseCommand<TOptions, TStore, TName> & {
+    handler: Handler<InferOptions<TOptions>, TStore, TName>;
+    render: RenderFunction<InferOptions<TOptions>, TStore>;
+}) | (BaseCommand<TOptions, TStore, TName> & {
+    handler?: never;
+    render?: never;
+});
+type InferSchema<T> = T extends StandardSchemaV1<any, infer Out> ? Out : never;
+export type InferOptions<T extends Options> = {
+    [K in keyof T]: T[K] extends CLIOption<infer S> ? InferSchema<S> : never;
+};
+export type MergedOptions<TOptions extends Options> = typeof GLOBAL_FLAGS & TOptions;
+export type InferMergedOptions<TOptions extends Options> = InferOptions<MergedOptions<TOptions>>;
+export type Handler<TFlags = Record<string, unknown>, TStore = {}, TCommandName extends string = string> = (args: HandlerArgs<TFlags, TStore, TCommandName>) => void | Promise<void>;
+export interface HandlerArgs<TFlags = Record<string, unknown>, TStore = {}, TCommandName extends string = string> {
+    flags: TFlags;
+    positional: string[];
+    shell: typeof Bun.$;
+    env: typeof process.env;
+    cwd: string;
+    prompt: typeof import("@reliverse/rempts-utils").prompt;
+    spinner: typeof import("@reliverse/rempts-utils").spinner;
+    colors: typeof import("@reliverse/relico").relico;
+    context?: import("./plugin/types.js.js").CommandContext<any>;
+    hooks?: Record<string, any>;
+    terminal: TerminalInfo;
+    runtime: RuntimeInfo;
+}
+export interface TerminalInfo {
+    width: number;
+    height: number;
+    isInteractive: boolean;
+    isCI: boolean;
+    supportsColor: boolean;
+    supportsMouse: boolean;
+}
+export interface RuntimeInfo {
+    startTime: number;
+    args: string[];
+    command: string;
+}
+export interface CLIOption<S extends StandardSchemaV1 = StandardSchemaV1> {
+    schema: S;
+    short?: string;
+    description?: string;
+    default?: unknown;
+}
+export type Options = Record<string, CLIOption<any>>;
+export declare function defineCommand<TOptions extends Options = Options, TStore = {}>(command: Command<TOptions, TStore>): Command<TOptions, TStore>;
+import type { RemptsConfig } from "./config.js";
+export type { RemptsConfig } from "./config.js";
+export { remptsConfigSchema } from "./config.js";
+export type PluginConfig = import("./plugin/types.js.js").PluginConfig;
+export type RegisteredCommands = Record<string, Command<any, any, any>>;
+/**
+ * Get command options type from registered commands
+ * Uses Standard Schema's InferOutput to extract types from schemas
+ */
+export type CommandOptions<T extends keyof RegisteredCommands> = RegisteredCommands[T] extends Command<infer TOptions, any, any> ? InferOptions<TOptions> : never;
+export type CommandFlags<TCommand extends Command<any, any, any>> = TCommand extends Command<infer TOptions, any, any> ? InferOptions<TOptions> : never;
+/**
+ * Get all registered command names
+ */
+export type RegisteredCommandNames = keyof RegisteredCommands;
+export type ResolvedConfig = Required<Omit<RemptsConfig, "build" | "dev" | "test" | "workspace" | "release">> & {
+    build: NonNullable<RemptsConfig["build"]>;
+    dev: NonNullable<RemptsConfig["dev"]>;
+    test: NonNullable<RemptsConfig["test"]>;
+    workspace: NonNullable<RemptsConfig["workspace"]>;
+    release: NonNullable<RemptsConfig["release"]>;
+};
+/**
+ * Hook context passed to before/after hooks
+ */
+export interface HookContext<TStore = {}> {
+    /** Global flags parsed from command line */
+    flags: Record<string, unknown>;
+    /** Store from plugins (if any) */
+    store: TStore;
+    /** Environment variables */
+    env: typeof process.env;
+    /** Current working directory */
+    cwd: string;
+    /** Set data that will be available to command handlers */
+    set(key: string, value: any): void;
+    /** Get data that was set by hooks */
+    get(key: string): any;
+}
+/**
+ * Before hook function type
+ */
+export type BeforeHook<TStore = {}> = (context: HookContext<TStore>) => void | Promise<void>;
+/**
+ * After hook function type
+ */
+export type AfterHook<TStore = {}> = (context: HookContext<TStore> & {
+    exitCode: number;
+    error?: Error;
+}) => void | Promise<void>;
+/**
+ * Rich validation error with context information
+ */
+export declare class RemptsValidationError extends Error {
+    readonly context: {
+        option: string;
+        value: unknown;
+        command: string;
+        expectedType: string;
+        hint?: string;
+    };
+    constructor(message: string, context: {
+        option: string;
+        value: unknown;
+        command: string;
+        expectedType: string;
+        hint?: string;
+    });
+    toString(): string;
+}
+export declare function option<S extends StandardSchemaV1>(schema: S, metadata?: {
+    short?: string;
+    description?: string;
+    default?: unknown;
+}): CLIOption<S>;

package/dist/types.js

@@ -0,0 +1,25 @@
+export function defineCommand(command) {
+  return command;
+}
+export { remptsConfigSchema } from "./config.js";
+export class RemptsValidationError extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "RemptsValidationError";
+  }
+  toString() {
+    return `${this.name}: Invalid option '${this.context.option}' for command '${this.context.command}'
+    
+Expected: ${this.context.expectedType}
+Received: ${typeof this.context.value} (${JSON.stringify(this.context.value)})
+${this.context.hint ? `
+Hint: ${this.context.hint}` : ""}`;
+  }
+}
+export function option(schema, metadata) {
+  return {
+    schema,
+    ...metadata
+  };
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Simple logger implementation
+ */
+export interface Logger {
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+}
+export declare function createLogger(namespace: string): Logger;

package/dist/utils/logger.js

@@ -0,0 +1,27 @@
+export function createLogger(namespace) {
+  const prefix = `[${namespace}]`;
+  const debugEnabled = process.env.dler_DEBUG === "true" || process.env.dler_DEBUG?.includes(namespace);
+  const silent = process.env.dler_SILENT === "true" || process.env.NODE_ENV === "test";
+  return {
+    info(message, ...args) {
+      if (!silent) {
+        console.log(prefix, message, ...args);
+      }
+    },
+    warn(message, ...args) {
+      if (!silent) {
+        console.warn(prefix, message, ...args);
+      }
+    },
+    error(message, ...args) {
+      if (!silent) {
+        console.error(prefix, message, ...args);
+      }
+    },
+    debug(message, ...args) {
+      if (debugEnabled && !silent) {
+        console.log(`${prefix} [DEBUG]`, message, ...args);
+      }
+    }
+  };
+}

package/dist/utils/merge.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Deep merge utility for configuration objects
+ */
+/**
+ * Deep merge multiple objects
+ * Arrays are concatenated, objects are recursively merged
+ */
+export declare function deepMerge<T = any>(...objects: Partial<T>[]): T;
+/**
+ * Shallow merge multiple objects
+ * Last value wins for all properties
+ */
+export declare function shallowMerge<T = any>(...objects: Partial<T>[]): T;

package/dist/utils/merge.js

@@ -0,0 +1,25 @@
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && value.constructor === Object && Object.prototype.toString.call(value) === "[object Object]";
+}
+export function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      const existing = result[key];
+      if (Array.isArray(value)) {
+        result[key] = Array.isArray(existing) ? [...existing, ...value] : [...value];
+      } else if (isPlainObject(value)) {
+        result[key] = isPlainObject(existing) ? deepMerge(existing, value) : { ...value };
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+export function shallowMerge(...objects) {
+  return Object.assign({}, ...objects);
+}

package/dist/utils/mod.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility exports
+ */
+export type { Logger } from "./logger.js";
+export { createLogger } from "./logger.js";
+export { deepMerge, shallowMerge } from "./merge.js";

package/dist/utils/mod.js

@@ -0,0 +1,2 @@
+export { createLogger } from "./logger.js";
+export { deepMerge, shallowMerge } from "./merge.js";

package/dist/utils/type-helpers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Type utilities inspired by TanStack Router for advanced type manipulation
+ */
+export type UnionToIntersection<T> = (T extends any ? (arg: T) => any : never) extends (arg: infer T) => any ? T : never;
+export type Constrain<T, TConstraint, TDefault = TConstraint> = (T extends TConstraint ? T : never) | TDefault;
+export type PickRequired<T> = {
+    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+export type PickOptional<T> = {
+    [K in keyof T as undefined extends T[K] ? K : never]: T[K];
+};
+export type ExtractPrimitives<TUnion> = TUnion extends MergeAllPrimitive ? TUnion : TUnion extends object ? never : TUnion;
+export type MergeAllPrimitive = readonly any[] | number | string | bigint | boolean | symbol | undefined | null;
+export type ExtractObjects<TUnion> = TUnion extends MergeAllPrimitive ? never : TUnion;
+export type PartialMergeAllObject<TUnion> = ExtractObjects<TUnion> extends infer TObj ? [TObj] extends [never] ? never : {
+    [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any ? TKey extends keyof TObj ? TObj[TKey] : never : never;
+} : never;
+export type PartialMergeAll<TUnion> = ExtractPrimitives<TUnion> | PartialMergeAllObject<TUnion>;
+export type MergeAllObjects<TUnion, TIntersected = UnionToIntersection<ExtractObjects<TUnion>>> = [
+    keyof TIntersected
+] extends [never] ? never : {
+    [TKey in keyof TIntersected]: TUnion extends any ? TUnion[TKey & keyof TUnion] : never;
+};
+export type MergeAll<TUnion> = MergeAllObjects<TUnion> | ExtractPrimitives<TUnion>;
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type IsAny<TValue, TYesResult, TNoResult = TValue> = 1 extends 0 & TValue ? TYesResult : TNoResult;
+export type PickAsRequired<TValue, TKey extends keyof TValue> = Omit<TValue, TKey> & Required<Pick<TValue, TKey>>;
+export type WithoutEmpty<T> = T extends any ? ({} extends T ? never : T) : never;
+export type Expand<T> = T extends object ? T extends infer O ? O extends Function ? O : {
+    [K in keyof O]: O[K];
+} : never : T;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type MakeDifferenceOptional<TLeft, TRight> = keyof TLeft & keyof TRight extends never ? TRight : Omit<TRight, keyof TLeft & keyof TRight> & {
+    [K in keyof TLeft & keyof TRight]?: TRight[K];
+};
+export type IsUnion<T, U extends T = T> = (T extends any ? U extends T ? false : true : never) extends false ? false : true;
+export type IsNonEmptyObject<T> = T extends object ? (keyof T extends never ? false : true) : false;
+export type Assign<TLeft, TRight> = TLeft extends any ? TRight extends any ? IsNonEmptyObject<TLeft> extends false ? TRight : IsNonEmptyObject<TRight> extends false ? TLeft : keyof TLeft & keyof TRight extends never ? TLeft & TRight : Omit<TLeft, keyof TRight> & TRight : never : never;
+export type IntersectAssign<TLeft, TRight> = TLeft extends any ? TRight extends any ? IsNonEmptyObject<TLeft> extends false ? TRight : IsNonEmptyObject<TRight> extends false ? TLeft : TRight & TLeft : never : never;

package/dist/validation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Runtime validation utilities for Rempts
+ */
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+/**
+ * Validate a value against a schema at runtime
+ */
+export declare function validateValue(value: unknown, schema: StandardSchemaV1, context: {
+    option: string;
+    command: string;
+}): Promise<unknown>;
+/**
+ * Validate multiple values against their schemas
+ */
+export declare function validateValues(values: Record<string, unknown>, schemas: Record<string, StandardSchemaV1>, command: string): Promise<Record<string, unknown>>;
+/**
+ * Check if a value matches a schema type
+ */
+export declare function isValueOfType(value: unknown, expectedType: string): boolean;
+/**
+ * Create a validator function from a schema
+ */
+export declare function createValidator(schema: StandardSchemaV1): (value: unknown, context: {
+    option: string;
+    command: string;
+}) => Promise<unknown>;
+/**
+ * Batch validate multiple values
+ */
+export declare function createBatchValidator(schemas: Record<string, StandardSchemaV1>): (values: Record<string, unknown>, command: string) => Promise<Record<string, unknown>>;

package/dist/validation.js

@@ -0,0 +1,121 @@
+import { RemptsValidationError } from "./types.js";
+export async function validateValue(value, schema, context) {
+  try {
+    const result = await schema["~standard"].validate(value);
+    if (result.issues && result.issues.length > 0) {
+      const issue = result.issues[0];
+      if (!issue) {
+        return value;
+      }
+      const expectedType = extractSchemaType(schema);
+      const hint = generateHint(schema, value);
+      throw new RemptsValidationError(`Invalid option '${context.option}': ${issue.message}`, {
+        option: context.option,
+        value,
+        command: context.command,
+        expectedType,
+        hint
+      });
+    }
+    return "value" in result ? result.value : value;
+  } catch (error) {
+    if (error instanceof RemptsValidationError) {
+      throw error;
+    }
+    throw new RemptsValidationError(`Validation failed for option '${context.option}': ${error}`, {
+      option: context.option,
+      value,
+      command: context.command,
+      expectedType: "unknown",
+      hint: "Check the value format and try again"
+    });
+  }
+}
+export async function validateValues(values, schemas, command) {
+  const results = {};
+  const errors = [];
+  for (const [key, value] of Object.entries(values)) {
+    const schema = schemas[key];
+    if (!schema) {
+      results[key] = value;
+      continue;
+    }
+    try {
+      results[key] = await validateValue(value, schema, {
+        option: key,
+        command
+      });
+    } catch (error) {
+      if (error instanceof RemptsValidationError) {
+        errors.push(error.toString());
+      } else {
+        errors.push(`Validation error for ${key}: ${error}`);
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Validation failed:
+${errors.join("\n")}`);
+  }
+  return results;
+}
+export function isValueOfType(value, expectedType) {
+  switch (expectedType) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number";
+    case "boolean":
+      return typeof value === "boolean";
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+function extractSchemaType(schema) {
+  if ("type" in schema && typeof schema.type === "string") {
+    return schema.type;
+  }
+  if ("enum" in schema) {
+    return "enum";
+  }
+  if ("items" in schema) {
+    return "array";
+  }
+  if ("properties" in schema) {
+    return "object";
+  }
+  if ("format" in schema) {
+    return "string";
+  }
+  return "unknown";
+}
+function generateHint(schema, value) {
+  const type = extractSchemaType(schema);
+  if (type === "boolean" && typeof value === "string") {
+    return "Use --flag or --no-flag for boolean options";
+  }
+  if (type === "number" && typeof value === "string") {
+    return "Provide a numeric value";
+  }
+  if (type === "array" && !Array.isArray(value)) {
+    return "Provide a comma-separated list of values";
+  }
+  if (type === "enum" && typeof value === "string") {
+    return "Choose from the available options";
+  }
+  return "";
+}
+export function createValidator(schema) {
+  return async (value, context) => {
+    return validateValue(value, schema, context);
+  };
+}
+export function createBatchValidator(schemas) {
+  return async (values, command) => {
+    return validateValues(values, schemas, command);
+  };
+}

package/package.json

@@ -1,58 +1,61 @@
 {
-  "description": "@reliverse/prompts is your modern, type-safe toolkit for building delightful CLI experiences. It's fast, flexible, and built with developer joy in mind. Forget the clutter — this is how CLI should feel.",
-  "license": "MIT",
   "name": "@reliverse/rempts-core",
-  "type": "module",
-  "version": "1.6.1",
-  "author": "reliverse",
-  "bugs": {
-    "email": "blefnk@gmail.com",
-    "url": "https://github.com/reliverse/prompts/issues"
-  },
+  "version": "2.3.1",
+  "description": "Minimal, type-safe CLI framework for Bun",
   "keywords": [
-    "reliverse",
-    "prompts"
+    "bun",
+    "cli",
+    "command-line",
+    "framework",
+    "rempts",
+    "type-safe",
+    "typescript"
   ],
+  "homepage": "https://github.com/reliverse/dler#readme",
+  "bugs": {
+    "url": "https://github.com/reliverse/dler/issues"
+  },
+  "license": "MIT",
+  "author": "blefnk",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/reliverse/prompts.git"
-  },
-  "dependencies": {
-    "@figliolia/chalk-animation": "^1.0.4",
-    "@reliverse/relico": "^1.1.0",
-    "@reliverse/relinka": "^1.3.7",
-    "@reliverse/runtime": "^1.0.3",
-    "ansi-escapes": "^7.0.0",
-    "c12": "^3.0.2",
-    "cli-spinners": "^3.2.0",
-    "detect-package-manager": "^3.0.2",
-    "figlet": "^1.8.0",
-    "fs-extra": "^11.3.0",
-    "gradient-string": "^3.0.0",
-    "log-update": "^6.1.0",
-    "node-emoji": "^2.2.0",
-    "ora": "^8.2.0",
-    "pathe": "^2.0.3",
-    "scule": "^1.3.0",
-    "sisteransi": "^1.0.5",
-    "terminal-kit": "^3.1.2",
-    "terminal-size": "^4.0.0",
-    "ts-regex-builder": "^1.8.2",
-    "wrap-ansi": "^9.0.0"
-  },
-  "devDependencies": {},
-  "exports": {
-    ".": "./bin/main.js"
+    "url": "https://github.com/reliverse/dler.git",
+    "directory": "packages/core"
   },
   "files": [
-    "bin",
-    "package.json",
+    "dist",
     "README.md",
-    "LICENSE"
+    "src"
   ],
-  "main": "./bin/main.js",
-  "module": "./bin/main.js",
+  "type": "module",
+  "module": "./src/mod.ts",
+  "types": "./src/mod.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "import": "./dist/mod.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin/mod.d.ts",
+      "import": "./dist/plugin/mod.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/mod.d.ts",
+      "import": "./dist/utils/mod.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@reliverse/relico": "2.3.1",
+    "@reliverse/rempts-utils": "2.3.1",
+    "@standard-schema/spec": "^1.1.0",
+    "@standard-schema/utils": "^0.3.0",
+    "arktype": "^2.1.29",
+    "zustand": "^5.0.9"
+  },
+  "engines": {
+    "bun": ">=1.3.5"
   }
 }