@reliverse/rempts-core 1.6.1 → 2.3.1

package/dist/config-loader.d.ts

@@ -0,0 +1,42 @@
+export interface LoadedConfig {
+    name?: string;
+    version?: string;
+    description?: string;
+    commands?: {
+        manifest?: string;
+        directory?: string;
+        generateReport?: boolean;
+    };
+    build: {
+        entry?: string | string[];
+        outdir?: string;
+        targets: string[];
+        compress: boolean;
+        minify: boolean;
+        external?: string[];
+        sourcemap: boolean;
+    };
+    dev: {
+        watch: boolean;
+        inspect: boolean;
+        port?: number;
+    };
+    test: {
+        pattern: string | string[];
+        coverage: boolean;
+        watch: boolean;
+    };
+    workspace: {
+        packages?: string[];
+        shared?: any;
+        versionStrategy: "fixed" | "independent";
+    };
+    release: {
+        npm: boolean;
+        github: boolean;
+        tagFormat: string;
+        conventionalCommits: boolean;
+    };
+    plugins: any[];
+}
+export declare function loadConfig(cwd?: any): Promise<LoadedConfig>;

package/dist/config-loader.js

@@ -0,0 +1,20 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { remptsConfigSchema } from "./config.js";
+const CONFIG_NAMES = ["dler.config.ts", "dler.config.js", "dler.config.mjs"];
+export async function loadConfig(cwd = process.cwd()) {
+  for (const configName of CONFIG_NAMES) {
+    const configPath = path.join(cwd, configName);
+    if (existsSync(configPath)) {
+      try {
+        const module = await import(configPath);
+        const config = remptsConfigSchema.assert(module.default || module);
+        return config;
+      } catch (error) {
+        console.error(`Error loading config from ${configPath}:`, error);
+        throw error;
+      }
+    }
+  }
+  throw new Error(`No configuration file found. Please create one of: ${CONFIG_NAMES.join(", ")}`);
+}

package/dist/config.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Comprehensive Rempts configuration schema with enhanced validation
+ * Codegen and TypeScript are REQUIRED for all Rempts projects
+ */
+export declare const remptsConfigSchema: import("arktype/out/variants/object").ObjectType<{
+    name?: string | undefined;
+    version?: string | undefined;
+    description?: string | undefined;
+    commands?: {
+        directory?: string | undefined;
+        generateReport?: boolean | undefined;
+    } | undefined;
+    build?: {
+        entry?: string | string[] | undefined;
+        outdir?: string | undefined;
+        targets?: string[] | undefined;
+        compress?: boolean | undefined;
+        minify?: boolean | undefined;
+        external?: string[] | undefined;
+        sourcemap?: boolean | undefined;
+    } | undefined;
+    dev?: {
+        watch?: boolean | undefined;
+        inspect?: boolean | undefined;
+        port?: number | undefined;
+    } | undefined;
+    test?: {
+        pattern?: string | string[] | undefined;
+        coverage?: boolean | undefined;
+        watch?: boolean | undefined;
+    } | undefined;
+    workspace?: {
+        packages?: string[] | undefined;
+        shared?: unknown;
+        versionStrategy?: "fixed" | "independent" | undefined;
+    } | undefined;
+    release?: {
+        npm?: boolean | undefined;
+        github?: boolean | undefined;
+        tagFormat?: string | undefined;
+        conventionalCommits?: boolean | undefined;
+    } | undefined;
+    plugins?: unknown[] | undefined;
+}, {}>;
+/**
+ * Inferred TypeScript type from the schema
+ * This ensures runtime validation matches compile-time types
+ */
+export type RemptsConfig = typeof remptsConfigSchema.infer;
+/**
+ * Strict schema for CLI creation that requires name and version
+ * Codegen and TypeScript are automatically enabled
+ */
+export declare const remptsConfigStrictSchema: import("arktype/out/variants/object").ObjectType<{
+    name: string;
+    version: string;
+    description?: string | undefined;
+    commands?: {
+        directory?: string | undefined;
+        generateReport?: boolean | undefined;
+    } | undefined;
+    build?: {
+        entry?: string | string[] | undefined;
+        outdir?: string | undefined;
+        targets?: string[] | undefined;
+        compress?: boolean | undefined;
+        minify?: boolean | undefined;
+        external?: string[] | undefined;
+        sourcemap?: boolean | undefined;
+    } | undefined;
+    dev?: {
+        watch?: boolean | undefined;
+        inspect?: boolean | undefined;
+        port?: number | undefined;
+    } | undefined;
+    test?: {
+        pattern?: string | string[] | undefined;
+        coverage?: boolean | undefined;
+        watch?: boolean | undefined;
+    } | undefined;
+    workspace?: {
+        packages?: string[] | undefined;
+        shared?: unknown;
+        versionStrategy?: "fixed" | "independent" | undefined;
+    } | undefined;
+    release?: {
+        npm?: boolean | undefined;
+        github?: boolean | undefined;
+        tagFormat?: string | undefined;
+        conventionalCommits?: boolean | undefined;
+    } | undefined;
+    plugins?: unknown[] | undefined;
+}, {}>;
+export type RemptsConfigStrict = typeof remptsConfigStrictSchema.infer;
+/**
+ * Helper function to define configuration with type safety
+ * Codegen and TypeScript are automatically configured
+ */
+export declare function defineConfig(config: RemptsConfig): RemptsConfig;

package/dist/config.js

@@ -0,0 +1,188 @@
+import { type } from "arktype";
+const VersionStrategy = type("'fixed'|'independent'");
+const PortNumber = type("number.integer > 0 & number.integer < 65536").configure({
+  description: "a valid port number"
+}).narrow((n) => {
+  const reservedPorts = [22, 80, 443, 3306, 5432];
+  if (reservedPorts.includes(n)) {
+    console.warn(`Port ${n} is commonly used by system services and may cause conflicts`);
+  }
+  return true;
+});
+const SafePath = type("string").configure({
+  description: "a valid file path"
+}).narrow((path, ctx) => {
+  if (!path.trim()) {
+    return ctx.reject("path cannot be empty or only whitespace");
+  }
+  if (path.includes("../") || path.includes("..\\")) {
+    console.warn("path contains directory traversal (..) which may be unsafe");
+  }
+  return true;
+});
+const BuildTargets = type("string[]").configure({
+  description: "an array of valid build targets"
+}).narrow((targets, ctx) => {
+  const validTargets = [
+    "darwin-arm64",
+    "darwin-x64",
+    "linux-arm64",
+    "linux-x64",
+    "windows-x64",
+    "bun-linux-x64-modern",
+    "bun-darwin-x64-modern",
+    "bun-windows-x64-modern"
+  ];
+  const invalidTargets = targets.filter((target) => !validTargets.includes(target));
+  if (invalidTargets.length > 0) {
+    return ctx.reject({
+      expected: `valid build targets: ${validTargets.join(", ")}`,
+      actual: `invalid targets: ${invalidTargets.join(", ")}`
+    });
+  }
+  return true;
+});
+export const remptsConfigSchema = type({
+  // Base configuration (required for CLI creation, optional for partial configs)
+  "name?": type("string").configure({
+    description: "package name (npm naming conventions)"
+  }).narrow((name, ctx) => {
+    if (name.length < 1) {
+      return ctx.reject("package name cannot be empty");
+    }
+    if (name.length > 214) {
+      return ctx.reject("package name too long (max 214 characters)");
+    }
+    return true;
+  }),
+  "version?": type("string.semver").configure({
+    description: "semantic version string"
+  }),
+  "description?": type("string").configure({
+    description: "package description"
+  }).narrow((desc, ctx) => {
+    return desc.length <= 300 || ctx.reject("description too long (max 300 characters)");
+  }),
+  // Commands configuration
+  "commands?": type({
+    "directory?": SafePath.configure({
+      description: "directory containing command files following pattern: <cmd-name>/cmd.{ts,js,mjs}"
+    }),
+    "generateReport?": "boolean"
+  }).configure({
+    description: "command-related configuration"
+  }),
+  // Build configuration - TypeScript REQUIRED
+  "build?": type({
+    "entry?": type("string|string[]").configure({
+      description: "entry file(s) for bundling"
+    }).narrow((entry, _ctx) => {
+      const entries = Array.isArray(entry) ? entry : [entry];
+      if (entries.length === 0) {
+        return _ctx.reject("at least one entry file must be specified");
+      }
+      const hasValidExtension = entries.every((e) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(e));
+      if (!hasValidExtension) {
+        console.warn(
+          "entry files should typically have .ts, .tsx, .js, .jsx, .mjs, or .cjs extensions"
+        );
+      }
+      return true;
+    }),
+    "outdir?": SafePath.configure({
+      description: "output directory for build artifacts"
+    }),
+    "targets?": BuildTargets,
+    "compress?": "boolean",
+    "minify?": "boolean",
+    "external?": type("string[]").configure({
+      description: "external dependencies to exclude from bundle"
+    }).narrow((externals, _ctx) => {
+      const problematic = externals.filter(
+        (ext) => ext.startsWith("@types/") || ext.includes("*")
+      );
+      if (problematic.length > 0) {
+        console.warn(`potentially problematic externals detected: ${problematic.join(", ")}`);
+      }
+      return true;
+    }),
+    "sourcemap?": "boolean"
+  }).configure({
+    description: "build configuration for bundling and compilation"
+  }),
+  // Development configuration
+  "dev?": type({
+    "watch?": "boolean",
+    "inspect?": "boolean",
+    "port?": PortNumber
+  }).configure({
+    description: "development server configuration"
+  }),
+  // Test configuration
+  "test?": type({
+    "pattern?": type("string|string[]").configure({
+      description: "glob patterns for test files"
+    }).narrow((patterns, _ctx) => {
+      const patternList = Array.isArray(patterns) ? patterns : [patterns];
+      const invalidPatterns = patternList.filter((p) => p.includes("../") || p.startsWith("/"));
+      if (invalidPatterns.length > 0) {
+        console.warn(`glob patterns should be relative: ${invalidPatterns.join(", ")}`);
+      }
+      return true;
+    }),
+    "coverage?": "boolean",
+    "watch?": "boolean"
+  }).configure({
+    description: "test configuration"
+  }),
+  // Workspace configuration
+  "workspace?": type({
+    "packages?": type("string[]").configure({
+      description: "array of package paths in the workspace"
+    }).narrow((packages, _ctx) => {
+      if (packages.length === 0) {
+        console.warn("workspace.packages is empty - no packages will be included");
+      }
+      const absolutePaths = packages.filter((pkg) => pkg.startsWith("/"));
+      if (absolutePaths.length > 0) {
+        console.warn("workspace packages should use relative paths, not absolute paths");
+      }
+      return true;
+    }),
+    "shared?": "unknown",
+    "versionStrategy?": VersionStrategy.configure({
+      description: "how versions are managed across workspace packages"
+    })
+  }).configure({
+    description: "monorepo workspace configuration"
+  }),
+  // Release configuration
+  "release?": type({
+    "npm?": "boolean",
+    "github?": "boolean",
+    "tagFormat?": type("string").configure({
+      description: "format for git tags (e.g., 'v${version}')"
+    }).narrow((format, ctx) => {
+      if (!format.includes("${version}")) {
+        return ctx.reject("tagFormat must include '${version}' placeholder");
+      }
+      return true;
+    }),
+    "conventionalCommits?": "boolean"
+  }).configure({
+    description: "release and publishing configuration"
+  }),
+  // Plugins configuration
+  "plugins?": type("unknown[]").configure({
+    description: "array of plugin configurations"
+  })
+}).configure({
+  description: "Rempts CLI configuration schema with comprehensive validation"
+});
+export const remptsConfigStrictSchema = remptsConfigSchema.and({
+  name: "string",
+  version: "string.semver"
+});
+export function defineConfig(config) {
+  return config;
+}

package/dist/file-loader.d.ts

@@ -0,0 +1,43 @@
+import type { Command } from "./types.js";
+/**
+ * Create a file command loader
+ */
+export declare function createFileCommandLoader(): {
+    /**
+     * Load commands from a directory structure
+     * @param cmdsDir Directory containing command files following pattern: <cmd-name>/cmd.{ts,js,mjs}
+     * @returns Promise resolving to loaded command tree
+     */
+    loadFromDirectory(cmdsDir: string): Promise<CommandFileTree>;
+    /**
+     * Load and register commands from file tree
+     * Returns commands with their names inferred from file paths
+     */
+    loadCommandsFromTree(tree: CommandFileTree): Promise<CommandWithName[]>;
+};
+/**
+ * Command with its inferred name from file path
+ */
+export interface CommandWithName {
+    name: string;
+    command: Command<any, any>;
+}
+/**
+ * Types for file-based command loading
+ */
+export interface CommandFileInfo {
+    filePath: string;
+    importPath: string;
+    commandName: string;
+}
+export interface CommandFileTree {
+    [key: string]: CommandFileTree | CommandFileInfo | undefined;
+}
+export interface CommandConflict {
+    commandName: string;
+    files: string[];
+}
+/**
+ * Utility function to load commands from directory
+ */
+export declare function loadCommandsFromDirectory(cmdsDir: string): Promise<CommandWithName[]>;

package/dist/file-loader.js

@@ -0,0 +1,199 @@
+import { join, relative } from "node:path";
+const CMD_FILE_PATTERN = /\/cmd\.[^.]+$/;
+const PATH_SEPARATOR_PATTERN = /\//g;
+export function createFileCommandLoader() {
+  return {
+    /**
+     * Load commands from a directory structure
+     * @param cmdsDir Directory containing command files following pattern: <cmd-name>/cmd.{ts,js,mjs}
+     * @returns Promise resolving to loaded command tree
+     */
+    async loadFromDirectory(cmdsDir) {
+      const commandFiles = await scanCommandFiles(cmdsDir);
+      const conflicts = detectConflicts(commandFiles, cmdsDir);
+      if (conflicts.length > 0) {
+        const conflictMessages = conflicts.map(
+          (conflict) => `Command "${conflict.commandName}" conflicts between:
+  - ${conflict.files[0]}
+  - ${conflict.files[1]}`
+        );
+        throw new Error(`Command conflicts detected:
+${conflictMessages.join("\n\n")}`);
+      }
+      return buildCommandTree(commandFiles, cmdsDir);
+    },
+    /**
+     * Load and register commands from file tree
+     * Returns commands with their names inferred from file paths
+     */
+    async loadCommandsFromTree(tree) {
+      return loadCommandsFromTree(tree);
+    }
+  };
+}
+async function scanCommandFiles(cmdsDir) {
+  try {
+    const glob = new Bun.Glob("**/cmd.{ts,js,mjs}");
+    const files = await Array.fromAsync(glob.scan({ cwd: cmdsDir }));
+    const commandFiles = [];
+    for (const file of files) {
+      const fullPath = join(cmdsDir, file);
+      commandFiles.push(fullPath);
+    }
+    return commandFiles;
+  } catch {
+    console.warn(`Warning: Could not scan commands directory: ${cmdsDir}`);
+    return [];
+  }
+}
+function detectConflicts(commandFiles, cmdsDir) {
+  const conflicts = [];
+  const commandMap = /* @__PURE__ */ new Map();
+  const directoryMap = /* @__PURE__ */ new Map();
+  for (const filePath of commandFiles) {
+    const relativePath = relative(cmdsDir, filePath);
+    const commandName = getCommandName(relativePath);
+    if (!commandMap.has(commandName)) {
+      commandMap.set(commandName, []);
+    }
+    commandMap.get(commandName)?.push(filePath);
+    const directory = relativePath.replace(CMD_FILE_PATTERN, "");
+    if (!directoryMap.has(directory)) {
+      directoryMap.set(directory, []);
+    }
+    directoryMap.get(directory)?.push(filePath);
+  }
+  const directoriesWithVariants = /* @__PURE__ */ new Set();
+  for (const [directory, files] of directoryMap) {
+    if (files.length > 1) {
+      conflicts.push({
+        commandName: `${directory} has multiple file variants`,
+        files
+      });
+      directoriesWithVariants.add(directory);
+    }
+  }
+  for (const [commandName, files] of commandMap) {
+    if (files.length > 1 && !directoriesWithVariants.has(commandName)) {
+      conflicts.push({ commandName, files });
+    }
+  }
+  return conflicts;
+}
+function getCommandName(filePath) {
+  const pathWithoutCmd = filePath.replace(CMD_FILE_PATTERN, "");
+  const trimmed = pathWithoutCmd.replace(/\/$/, "");
+  return trimmed.replace(PATH_SEPARATOR_PATTERN, " ").replace(/\s+/g, " ").trim();
+}
+async function buildCommandTree(commandFiles, cmdsDir) {
+  const tree = {};
+  for (const filePath of commandFiles) {
+    const relativePath = relative(cmdsDir, filePath);
+    const commandName = getCommandName(relativePath);
+    const commandNameParts = commandName.split(" ");
+    let current = tree;
+    for (let i = 0; i < commandNameParts.length - 1; i++) {
+      const part = commandNameParts[i];
+      if (!current[part]) {
+        current[part] = {};
+      } else if ("filePath" in current[part]) {
+        const existingCommand = current[part];
+        current[part] = {
+          // Store the parent command file under a special key or as the base
+          // We'll handle this in loadCommandsFromTree
+        };
+        const treeNode = current[part];
+        treeNode.__parent__ = existingCommand;
+      }
+      current = current[part];
+    }
+    const finalPart = commandNameParts.at(-1);
+    if (commandNameParts.length === 1 && finalPart in current && "filePath" in current[finalPart]) {
+      const existing = current[finalPart];
+      if (existing.filePath !== relativePath) {
+        throw new Error(
+          `Command conflict: "${finalPart}" is defined in both "${existing.filePath}" and "${relativePath}"`
+        );
+      }
+    }
+    current[finalPart] = {
+      filePath: relativePath,
+      importPath: getImportPath(filePath),
+      commandName
+    };
+  }
+  return tree;
+}
+function getImportPath(filePath) {
+  return `file://${filePath}`;
+}
+async function loadCommandsFromTree(tree) {
+  async function loadFromTree(obj, path = []) {
+    const loadedCommands = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "__parent__") {
+        const commandInfo = value;
+        try {
+          const module = await import(commandInfo.importPath);
+          const command = module.default || module;
+          loadedCommands.push({
+            name: commandInfo.commandName,
+            command
+          });
+        } catch (error) {
+          console.warn(`Failed to load command from ${commandInfo.importPath}:`, error);
+        }
+        continue;
+      }
+      if (typeof value === "object" && "filePath" in value) {
+        const commandInfo = value;
+        try {
+          const module = await import(commandInfo.importPath);
+          const command = module.default || module;
+          const inferredName = commandInfo.commandName;
+          loadedCommands.push({
+            name: inferredName,
+            command
+          });
+        } catch (error) {
+          console.warn(`Failed to load command from ${commandInfo.importPath}:`, error);
+        }
+      } else {
+        const subCommands = await loadFromTree(value, [...path, key]);
+        if (subCommands.length > 0) {
+          const parentCommandInfo = value.__parent__;
+          if (parentCommandInfo) {
+            try {
+              const module = await import(parentCommandInfo.importPath);
+              const parentCommand = module.default || module;
+              loadedCommands.push({
+                name: parentCommandInfo.commandName,
+                command: parentCommand
+              });
+            } catch (error) {
+              console.warn(
+                `Failed to load parent command from ${parentCommandInfo.importPath}:`,
+                error
+              );
+            }
+          } else {
+            const parentCommand = {
+              description: `${key} commands`
+            };
+            loadedCommands.push({
+              name: key,
+              command: parentCommand
+            });
+          }
+        }
+      }
+    }
+    return loadedCommands;
+  }
+  return await loadFromTree(tree);
+}
+export async function loadCommandsFromDirectory(cmdsDir) {
+  const loader = createFileCommandLoader();
+  const tree = await loader.loadFromDirectory(cmdsDir);
+  return loader.loadCommandsFromTree(tree);
+}

package/dist/global-flags.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Built-in global flags available to all commands
+ * Enhanced with better descriptions and validation
+ */
+export declare const GLOBAL_FLAGS: {
+    interactive: {
+        schema: import("arktype").BaseType<boolean | undefined, {}>;
+        short: string;
+        description: string;
+    };
+    tui: {
+        schema: import("arktype").BaseType<boolean | undefined, {}>;
+        description: string;
+    };
+    "no-tui": {
+        schema: import("arktype").BaseType<boolean | undefined, {}>;
+        description: string;
+    };
+    help: {
+        schema: import("arktype").BaseType<boolean | undefined, {}>;
+        short: string;
+        description: string;
+    };
+    version: {
+        schema: import("arktype").BaseType<boolean | undefined, {}>;
+        short: string;
+        description: string;
+    };
+};
+export interface GlobalFlags {
+    interactive?: boolean;
+    tui?: boolean;
+    "no-tui"?: boolean;
+    help?: boolean;
+    version?: boolean;
+}

package/dist/global-flags.js

@@ -0,0 +1,36 @@
+import { type } from "arktype";
+export const GLOBAL_FLAGS = {
+  interactive: {
+    schema: type("boolean | undefined").configure({
+      description: "enable interactive terminal user interface mode"
+    }),
+    short: "i",
+    description: "Run in interactive TUI mode"
+  },
+  tui: {
+    schema: type("boolean | undefined").configure({
+      description: "force terminal user interface mode"
+    }),
+    description: "Force TUI mode (same as --interactive)"
+  },
+  "no-tui": {
+    schema: type("boolean | undefined").configure({
+      description: "disable terminal user interface mode"
+    }),
+    description: "Disable TUI mode, use CLI handler instead"
+  },
+  help: {
+    schema: type("boolean | undefined").configure({
+      description: "display help information"
+    }),
+    short: "h",
+    description: "Show help"
+  },
+  version: {
+    schema: type("boolean | undefined").configure({
+      description: "display version information"
+    }),
+    short: "v",
+    description: "Show version"
+  }
+};

package/dist/mod.d.ts

@@ -0,0 +1,13 @@
+export { SchemaError } from "@standard-schema/utils";
+export { createApp, createCLI } from "./cli.js";
+export { defineConfig, type RemptsConfig, remptsConfigSchema } from "./config.js";
+export { type LoadedConfig, loadConfig } from "./config-loader.js";
+export type { CommandConflict, CommandFileInfo, CommandFileTree, } from "./file-loader.js";
+export { createFileCommandLoader, loadCommandsFromDirectory } from "./file-loader.js";
+export type { GlobalFlags } from "./global-flags.js";
+export { GLOBAL_FLAGS } from "./global-flags.js";
+export { clearTuiRenderer, getTuiRenderer, registerTuiRenderer, } from "./tui/registry.js";
+export type { CLI, CLIOption, Command, CommandOptions, Handler, HandlerArgs, Options, PluginConfig, RegisteredCommands, RenderArgs, RenderFunction, RenderResult, ResolvedConfig, RuntimeInfo, TerminalInfo, } from "./types.js";
+export { defineCommand, option } from "./types.js";
+export type { Assign, Constrain, DeepPartial, Expand, ExtractObjects, ExtractPrimitives, IntersectAssign, IsAny, IsNonEmptyObject, IsUnion, MakeDifferenceOptional, MergeAll, MergeAllObjects, NoInfer, PartialMergeAll, PickAsRequired, PickOptional, PickRequired, UnionToIntersection, WithoutEmpty, } from "./utils/type-helpers.js";
+export { createBatchValidator, createValidator, isValueOfType, validateValue, validateValues, } from "./validation.js";