@reliverse/rempts 1.7.41 → 1.7.43

package/LICENSE

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) Nazar Kornienko (blefnk), Reliverse
+Copyright (c) Nazar Kornienko (blefnk), Bleverse, Reliverse
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1210,6 +1210,219 @@ mycli --tags desktop
 
 The validation happens after type casting, so for example with numbers, the input will first be converted to a number and then checked against the allowed list.
 
+## Typed Commands System
+
+The typed commands system provides TypeScript intellisense and type safety for rempts launcher usage while maintaining dynamic code execution.
+
+- 🎯 **TypeScript Intellisense**: Full autocomplete for command names and arguments
+- 🔒 **Type Safety**: Compile-time checking for argument types and required fields
+- ⚡ **Dynamic Execution**: Commands are still loaded and executed dynamically
+- 📝 **Automatic Sync**: Utility script to keep types in sync with actual command definitions
+
+### Usage
+
+#### Basic Usage
+
+```typescript
+import { callCmd } from "~/app/cmds";
+
+// Simple command with typed arguments
+await callCmd("pub", { dev: true });
+
+// Command with multiple arguments
+await callCmd("check", {
+  directory: "src",
+  checks: "missing-deps,file-extensions",
+  strict: true,
+  json: false
+});
+
+// Command with no arguments
+await callCmd("update");
+
+// Generators with typed arguments
+await callCmd("rempts", {
+  init: "new-cmd another-cmd",
+  overwrite: true,
+  outFile: "src/app/cmds.ts"
+});
+```
+
+#### Advanced Usage
+
+```typescript
+import { getTypedCmd } from "~/app/cmds";
+
+// Get command instance for more control
+const { command, run } = await getTypedCmd("magic");
+
+console.log(`Running: ${command.meta.name}`);
+console.log(`Description: ${command.meta.description}`);
+
+await run({
+  targets: ["dist-npm", "dist-jsr"],
+  concurrency: 4,
+  stopOnError: true
+});
+```
+
+#### TypeScript Benefits
+
+##### 1. Command Name Autocomplete
+
+When you type `callCmd("`, TypeScript will show all available commands.
+
+##### 2. Argument Intellisense
+
+When you type the arguments object, you get full autocomplete for:
+
+- Argument names
+- Argument types
+- Required vs optional fields
+
+##### 3. Type Validation
+
+```typescript
+// ✅ Correct usage
+await callCmd("create", {
+  mode: "files",    // Only "template" | "files" allowed
+  multiple: true    // boolean
+});
+
+// ❌ TypeScript errors
+await callCmd("create", {
+  mode: "invalid",  // Error: not assignable to type
+  multiple: "yes"   // Error: string not assignable to boolean
+});
+```
+
+##### 4. Required Field Checking
+
+```typescript
+// ✅ Required field provided
+await callCmd("magic", {
+  targets: ["dist-npm"]  // Required field
+});
+
+// ❌ TypeScript error: missing required field 'targets'
+await callCmd("magic", {
+  concurrency: 4
+});
+```
+
+### Maintaining the System
+
+#### Adding New Commands
+
+1. Create your command in `src/app/<command-name>/cmd.ts` using `defineCommand` and `defineArgs`
+2. Run the generator: `dler rempts --overwrite`
+3. The `CommandArgsMap` interface in `src/app/cmds.ts` will be automatically updated
+
+#### Manual Updates
+
+The `CommandArgsMap` interface is auto-generated. If you need custom types, you can add manual type assertions (it is more recommended to edit your command file instead and regenerate the types):
+
+```typescript
+interface CommandArgsMap {
+  myCommand: {
+    // Use union types for specific values
+    mode: "development" | "production";
+    
+    // Use template literal types for patterns
+    version: `${number}.${number}.${number}`;
+    
+    // Use branded types for validation
+    port: number & { __brand: "Port" };
+  };
+}
+```
+
+### Migration from Old System
+
+#### Before (Old System, still supported)
+
+```typescript
+import { runCmd } from "@reliverse/rempts";
+import { getPubCmd } from "./app/cmds";
+
+// No type safety, string-based arguments
+await runCmd(await getPubCmd(), [`--dev=${isDev}`]);
+```
+
+### After (New System)
+
+```typescript
+import { callCmd } from "./app/cmds";
+
+// Full type safety and intellisense
+await callCmd("pub", { dev: isDev });
+```
+
+### Implementation Details
+
+The system works by:
+
+1. **Command Loading**: Commands are still loaded dynamically using `loadCommand()`
+2. **Argument Conversion**: Typed arguments are converted to string array format that `runCmd` expects
+3. **Type Mapping**: `CommandArgsMap` interface maps command names to their argument types
+4. **Generic Types**: `callCmd<T extends keyof CommandArgsMap>` provides type safety
+
+### Generator Usage
+
+The typed command system also supports calling generators with full intellisense:
+
+#### Creating New Commands
+
+```typescript
+// Create new commands with typed arguments
+await callCmd("rempts", {
+  init: "auth login logout",           // Commands to create
+  overwrite: true,                     // Overwrite existing
+  outFile: "src/app/cmds.ts"          // Export file path
+});
+
+// Create commands in custom location
+await callCmd("rempts", {
+  init: "api-handler",
+  customCmdsRoot: "src/modules/api",
+  outFile: "src/modules/api/exports.ts",
+  overwrite: true
+});
+```
+
+#### Regenerating Exports
+
+```typescript
+// Regenerate exports file only
+await callCmd("rempts", {
+  overwrite: true,
+  outFile: "src/app/cmds.ts"
+});
+
+// Generate exports for specific directories
+await callCmd("rempts", {
+  cmdDirs: ["build", "pub", "magic"],
+  outFile: "src/app/core-cmds.ts",
+  overwrite: true
+});
+```
+
+#### Batch Operations
+
+```typescript
+// Create multiple commands programmatically
+const modules = ["auth", "db", "api", "deploy"];
+
+for (const module of modules) {
+  await callCmd("rempts", {
+    init: `${module}-create ${module}-update ${module}-delete`,
+    customCmdsRoot: `src/modules/${module}`,
+    outFile: `src/modules/${module}/cmds.ts`,
+    overwrite: true
+  });
+}
+```
+
 ## Contributing
 
 Bug report? Prompt idea? Want to build the best DX possible?

package/bin/libs/confirm/confirm-mod.js

@@ -1,4 +1,4 @@
-import { colorize, re } from "@reliverse/relico";
+import { re } from "@reliverse/relico";
 import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline/promises";
 import { bar, msg } from "../msg-fmt/messages.js";
@@ -148,7 +148,7 @@ export async function confirmPrompt(options) {
         deleteLastLine();
         msg({
           type: "M_NULL",
-          title: `${colorize(re.reset(formattedBar), borderColor)}  ${re.reset(effectiveDefault ? "y" : "n")}`
+          title: `${formattedBar}  ${effectiveDefault ? "y" : "n"}`
         });
         result = effectiveDefault;
       } else if (answer === "y" || answer === "yes") {

package/bin/libs/input/input-alias.d.ts

@@ -1,4 +1,5 @@
 import type { InputPromptOptions } from "../../types.js";
-export declare const input: any;
-export declare const text: any;
-export declare const password: (options: Omit<InputPromptOptions, "mode">) => any;
+import { inputPrompt } from "./input-mod.js";
+export declare const input: typeof inputPrompt;
+export declare const text: typeof inputPrompt;
+export declare const password: (options: Omit<InputPromptOptions, "mode">) => Promise<string>;

package/bin/libs/launcher/command-typed.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from "./launcher-types";
+/**
+ * Static implementation functions for the typed command system.
+ * These functions are imported by the generated cmds.ts file.
+ */
+export declare function argsToStringArray(args: Record<string, unknown>): string[];
+export declare function createCallCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T, args?: TCommandArgsMap[T]) => Promise<void>)>;
+export declare function createGetTypedCmd<TCommandArgsMap>(): Promise<(<T extends keyof TCommandArgsMap>(cmdName: T) => Promise<{
+    command: Command;
+    run: (args?: TCommandArgsMap[T]) => Promise<void>;
+}>)>;
+export declare function callCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap, args?: TCommandArgsMap[keyof TCommandArgsMap]): Promise<void>;
+export declare function getTypedCmdImpl<TCommandArgsMap>(cmdName: keyof TCommandArgsMap): Promise<{
+    command: Command;
+    run: (args?: TCommandArgsMap[keyof TCommandArgsMap]) => Promise<void>;
+}>;

package/bin/libs/launcher/command-typed.js

@@ -0,0 +1,60 @@
+import { loadCommand } from "./command-runner.js";
+import { runCmd } from "./launcher-mod.js";
+export function argsToStringArray(args) {
+  const result = [];
+  for (const [key, value] of Object.entries(args)) {
+    if (value === void 0 || value === null) continue;
+    if (typeof value === "boolean") {
+      result.push(`--${key}=${value}`);
+    } else if (Array.isArray(value)) {
+      result.push(`--${key}=${value.join(",")}`);
+    } else {
+      result.push(`--${key}=${String(value)}`);
+    }
+  }
+  return result;
+}
+export async function createCallCmd() {
+  return async function callCmd(cmdName, args) {
+    try {
+      const command = await loadCommand(cmdName);
+      const stringArgs = args ? argsToStringArray(args) : [];
+      await runCmd(command, stringArgs);
+    } catch (error) {
+      console.error(`Error running command '${String(cmdName)}':`, error);
+      throw error;
+    }
+  };
+}
+export async function createGetTypedCmd() {
+  return async function getTypedCmd(cmdName) {
+    const command = await loadCommand(cmdName);
+    return {
+      command,
+      run: async (args) => {
+        const stringArgs = args ? argsToStringArray(args) : [];
+        await runCmd(command, stringArgs);
+      }
+    };
+  };
+}
+export async function callCmdImpl(cmdName, args) {
+  try {
+    const command = await loadCommand(cmdName);
+    const stringArgs = args ? argsToStringArray(args) : [];
+    await runCmd(command, stringArgs);
+  } catch (error) {
+    console.error(`Error running command '${String(cmdName)}':`, error);
+    throw error;
+  }
+}
+export async function getTypedCmdImpl(cmdName) {
+  const command = await loadCommand(cmdName);
+  return {
+    command,
+    run: async (args) => {
+      const stringArgs = args ? argsToStringArray(args) : [];
+      await runCmd(command, stringArgs);
+    }
+  };
+}

package/bin/mod.d.ts

@@ -13,13 +13,14 @@ export { input, text, password } from "./libs/input/input-alias.js";
 export { inputPrompt } from "./libs/input/input-mod.js";
 export { startPrompt, intro } from "./libs/intro/intro-alias.js";
 export { introPrompt } from "./libs/intro/intro-mod.js";
+export { loadCommand } from "./libs/launcher/command-runner.js";
+export { argsToStringArray, createCallCmd, createGetTypedCmd, callCmdImpl, getTypedCmdImpl, } from "./libs/launcher/command-typed.js";
 export { runMain } from "./libs/launcher/launcher-alias.js";
-export { defineCommand, showUsage, createCli, defineArgs, runCmd, runCmdWithSubcommands, } from "./libs/launcher/launcher-mod.js";
+export { defineCommand, showUsage, createCli, defineArgs, runCmdWithSubcommands, runCmd, } from "./libs/launcher/launcher-mod.js";
 export type { EmptyArgs, BaseArgProps, BaseArgDefinition, PositionalArgDefinition, BooleanArgDefinition, StringArgDefinition, NumberArgDefinition, ArrayArgDefinition, ArgDefinition, ArgDefinitions, CommandMeta, CommandSpec, CommandsMap, CommandContext, CommandRun, CommandHook, DefineCommandOptions, Command, InferArgTypes, FileBasedOptions, } from "./libs/launcher/launcher-types.js";
-export { loadCommand } from "./libs/launcher/run-command.js";
 export { addCompletions } from "./libs/launcher/trpc-orpc-support/completions.js";
 export { CliValidationError, FailedToExitError, } from "./libs/launcher/trpc-orpc-support/errors.js";
-export { TrpcCommand, parseRouter, createRpcCli, z, trpcServer, zod, } from "./libs/launcher/trpc-orpc-support/index.js";
+export { TrpcCommand, parseRouter, createRpcCli, z, } from "./libs/launcher/trpc-orpc-support/index.js";
 export { flattenedProperties, incompatiblePropertyPairs, getDescription, getSchemaTypes, getEnumChoices, } from "./libs/launcher/trpc-orpc-support/json-schema.js";
 export type { CommandJSON } from "./libs/launcher/trpc-orpc-support/json.js";
 export { commandToJSON } from "./libs/launcher/trpc-orpc-support/json.js";

package/bin/mod.js

@@ -24,16 +24,23 @@ export { input, text, password } from "./libs/input/input-alias.js";
 export { inputPrompt } from "./libs/input/input-mod.js";
 export { startPrompt, intro } from "./libs/intro/intro-alias.js";
 export { introPrompt } from "./libs/intro/intro-mod.js";
+export { loadCommand } from "./libs/launcher/command-runner.js";
+export {
+  argsToStringArray,
+  createCallCmd,
+  createGetTypedCmd,
+  callCmdImpl,
+  getTypedCmdImpl
+} from "./libs/launcher/command-typed.js";
 export { runMain } from "./libs/launcher/launcher-alias.js";
 export {
   defineCommand,
   showUsage,
   createCli,
   defineArgs,
-  runCmd,
-  runCmdWithSubcommands
+  runCmdWithSubcommands,
+  runCmd
 } from "./libs/launcher/launcher-mod.js";
-export { loadCommand } from "./libs/launcher/run-command.js";
 export { addCompletions } from "./libs/launcher/trpc-orpc-support/completions.js";
 export {
   CliValidationError,
@@ -43,9 +50,7 @@ export {
   TrpcCommand,
   parseRouter,
   createRpcCli,
-  z,
-  trpcServer,
-  zod
+  z
 } from "./libs/launcher/trpc-orpc-support/index.js";
 export {
   flattenedProperties,

package/package.json

@@ -3,10 +3,10 @@
     "@clack/prompts": "^0.11.0",
     "@figliolia/chalk-animation": "^1.0.4",
     "@inquirer/prompts": "^7.7.1",
-    "@orpc/server": "^1.7.4",
+    "@orpc/server": "^1.7.5",
     "@reliverse/pathkit": "^1.3.4",
     "@reliverse/reliarg": "^1.0.3",
-    "@reliverse/relico": "^1.1.2",
+    "@reliverse/relico": "^1.2.0",
     "@reliverse/relifso": "^1.4.5",
     "@reliverse/relinka": "^1.5.3",
     "@reliverse/runtime": "^1.0.3",
@@ -17,11 +17,11 @@
     "cli-spinners": "^3.2.0",
     "commander": "^14.0.0",
     "detect-package-manager": "^3.0.2",
-    "effect": "^3.17.1",
+    "effect": "^3.17.2",
     "enquirer": "^2.4.1",
     "figlet": "^1.8.2",
     "gradient-string": "^3.0.0",
-    "jiti": "^2.5.0",
+    "jiti": "^2.5.1",
     "json-schema": "^0.4.0",
     "log-update": "^6.1.0",
     "node-emoji": "^2.2.0",
@@ -36,7 +36,7 @@
     "tsx": "^4.20.3",
     "valibot": "^1.1.0",
     "wrap-ansi": "^9.0.0",
-    "zod": "^4.0.7",
+    "zod": "^4.0.10",
     "zod-to-json-schema": "^3.24.6"
   },
   "description": "@reliverse/rempts is a modern, type-safe toolkit for building delightful cli experiences. it's fast, flexible, and made for developer happiness. file-based commands keep things simple.",
@@ -44,7 +44,7 @@
   "license": "MIT",
   "name": "@reliverse/rempts",
   "type": "module",
-  "version": "1.7.41",
+  "version": "1.7.43",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",