@reliverse/rempts 1.6.2 → 1.7.1

package/LICENSE

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright (c) 2025 Nazar Kornienko (blefnk), Reliverse
+Copyright (c) Nazar Kornienko (blefnk), 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

@@ -1,70 +1,176 @@
-# @reliverse/rempts
+# rempts • powerful js/ts cli builder
 
-[💬 Discord](https://discord.gg/3GawfWfAPe) • [📦 NPM](https://npmjs.com/package/@reliverse/rempts) • [🧠 Docs](https://docs.reliverse.org/reliverse/rempts) • [🌐 JSR](https://jsr.io/@reliverse/rempts) • [✨ GitHub](https://github.com/reliverse/rempts)
+> @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—no clutter, just clean and easy workflows. this is how cli should feel.
 
-> @reliverse/rempts is a prompt library built with developer joy in mind. File-based commands. Flexible. Fast. Forget the clutter, it just works. This is a typesafe toolkit for building delightful CLI experiences.
+[💬 Discord](https://discord.gg/3GawfWfAPe) — [📦 NPM](https://npmjs.com/package/@reliverse/rempts) — [🧠 Docs](https://docs.reliverse.org/reliverse/rempts) — [🌐 JSR](https://jsr.io/@reliverse/rempts) — [✨ GitHub](https://github.com/reliverse/rempts)
 
-## Stop Fighting Your CLI
+## Features
 
-- CLIs are still the sharpest tool in the builder's belt. But most libraries are either clunky or crusty.
-- **@reliverse/rempts** is your end-to-end CLI UI + command framework — made for developer experience, DX precision, and high-context terminal UX.
-- No more hacking together `inquirer`, `citty`, `commander`, `chalk`, and other friends.
-
-## What Makes It Different?
-
-- 📂 File-based commands (optional)
+- 🫂 Rempts prevents you from fighting with your CLI tool
+- ✨ Rempts is your end-to-end CLI UI + command framework
+- 💪 Made for DX precision and high-context terminal UX
+- 📂 File-based commands (app router style by default)
+- 🏎️ Prompt engine that *feels* modern, actually is
 - 🧠 Type-safe from args to prompts
-- 🎨 Customizable themes, styled output
-- 🧩 Router + argument parser built-in
 - ⚡ Blazing-fast, no runtime baggage
+- 🧩 Router + argument parser built-in
+- 🎨 Customizable themes, styled output
+- 🚨 Crash-safe (Ctrl+C, SIGINT, errors)
 - 🪄 Minimal API surface, max expressiveness
-- 🏎️ Prompt engine that *feels* modern, actually is
 - 🧪 Scriptable for testing, stable for production
-- 🚨 Crash-safe (Ctrl+C, SIGINT, errors)
-- 🆕 Automatic commands creation via `rempts init --cmd my-cool-cmd`
+- 🆕 Automatic commands creation (via `dler init --cmd my-cool-cmd`)
+- 🏞️ No more hacking together `inquirer`, `citty`, `commander`, `chalk`
+
+## Installation
+
+```bash
+bun add @reliverse/rempts
+```
+
+## Usage Examples
+
+- [Prompts](#prompts)
+- [Launcher](#launcher)
 
 ## Screenshot
 
-![Rempts Example CLI Screenshot](./example.png)
+![Rempts Example CLI Screenshot](./example/example.png)
 
-## CLI Launcher (Router)
+## API Overview
 
-Finally, a full-featured CLI launcher without the ceremony. The launcher supports both programmatically defined subcommands and file-based routing, so you can structure your CLI however you like. It automatically detects and loads subcommands from your filesystem and provides robust usage and error handling out-of-the-box.
+All main prompts APIs are available from the package root:
 
-**Key Features:**
+```ts
+import {
+  // ...prompts
+  defineCommand, runMain, defineArgs,
+  inputPrompt, selectPrompt, multiselectPrompt, numberPrompt,
+  confirmPrompt, togglePrompt, spinnerTaskPrompt, progressTaskPrompt,
+  startPrompt, endPrompt, resultPrompt, nextStepsPrompt,
+  // ...hooks
+  useSpinner,
+  // ...launcher
+  runMain, defineCommand, defineArgs,
+  // ...types
+  // ...more
+} from "@reliverse/rempts";
+```
 
-- **File-Based & Defined Subcommands:**  
-  Use `subCommands` in your command definition or let the launcher automatically load commands from a specified directory.
+> See [`src/mod.ts`](./src/mod.ts) for the full list of exports.
 
-- **Automatic Command Detection:**  
-  The launcher scans your specified `cmdsRootPath` for command files matching common patterns such as:
-  - `arg-cmdName.{ts,js}`
-  - `cmdName/index.{ts,js}`
-  - `cmdName/cmdName-mod.{ts,js}`
-  - And more — with automatic usage output if a command file is not found.
+## Prompts
 
-- **Built-In Flag Handling:**  
-  Automatically processes global flags such as:
-  - `--help` and `-h` to show usage details.
-  - `--version` and `-v` to display version information.
-  - `--debug` for verbose logging during development.
+### Built-in Prompts
 
-- **Unified Argument Parsing:**  
-  Seamlessly combines positional and named arguments with zero configuration, auto-parsing booleans, strings, numbers, arrays, and even supporting negated flags like `--no-flag`.
+| Prompt                    | Description                                               |
+|---------------------------|-----------------------------------------------------------|
+| `inputPrompt`             | Single-line input (with mask support, e.g. for passwords) |
+| `selectPrompt`            | Single-choice radio menu                                  |
+| `multiselectPrompt`       | Multi-choice checkbox menu                                |
+| `numberPrompt`            | Type-safe number input                                    |
+| `confirmPrompt`           | Yes/No toggle                                             |
+| `togglePrompt`            | Custom on/off toggles                                     |
+| `progressTaskPrompt`      | Progress bar for async tasks                              |
+| `resultPrompt`            | Show results in a styled box                              |
+| `nextStepsPrompt`         | Show next steps in a styled list                          |
+| `startPrompt`/`endPrompt` | Makes CLI start/end flows look nice                       |
+| `spinnerTaskPrompt`       | Async loader with spinner (possibly will be deprecated)   |
+| `datePrompt`              | Date input with format validation                         |
+| `anykeyPrompt`            | Wait for any keypress                                     |
 
-- **Customizable Behavior:**  
-  Options such as `fileBasedCmds.enable`, `cmdsRootPath`, and `autoExit` allow you to tailor the launcher's behavior. For example, you can choose whether the process should exit automatically on error or allow manual error handling.
+### Hooks
 
-- **Error Management & Usage Output:**  
-  The launcher provides clear error messages for missing required arguments, invalid types, or command import issues, and it automatically displays usage information for your CLI.
+| Hook         | Description        |
+|--------------|--------------------|
+| `useSpinner` | Start/stop spinner |
+
+### Notices
+
+- `setup`/`cleanup` are now `onCmdStart`/`onCmdEnd` (old names still work for now).
+
+### Prompts Usage Example
+
+```ts
+import { relinka } from "@reliverse/relinka";
+
+import {
+  startPrompt,
+  inputPrompt,
+  selectPrompt,
+  defineCommand,
+  runMain
+} from "@reliverse/rempts";
+
+async function main() {
+  await startPrompt({ title: "Project Setup" });
+
+  const name = await inputPrompt({
+    title: "What's your project name?",
+    defaultValue: "my-cool-project",
+  });
+
+  const framework = await selectPrompt({
+    title: "Pick your framework",
+    options: [
+      { value: "next", label: "Next.js" },
+      { value: "svelte", label: "SvelteKit" },
+      { value: "start", label: "TanStack Start" },
+    ],
+    defaultValue: "next",
+  });
+
+  console.log("Your result:", { name, framework });
+};
+
+await main();
+```
+
+## Launcher
+
+### Terminology
+
+- **Launcher/Router**: The main entry point for your CLI. Visit [CLI Launcher (Router)](#cli-launcher-router) section to learn more.
+- **Command/Subcommand**: A command is a function that defines the behavior of a CLI.
+- **Argument**: An argument is a value that is passed to a command.
+- **Flag**: A flag is a boolean argument that is used to enable or disable a feature.
+- **Option**: An option is a named argument that is used to configure a command.
+
+#### Launcher Usage Example
+
+‼️ Go to [Usage Examples](#usage-examples) section for a more detailed example.
+
+```ts
+import { relinka } from "@reliverse/relinka";
+
+import { defineCommand, runMain } from "~/mod.js";
+
+const main = defineCommand({
+  meta: {
+    name: "rempts",
+    version: "1.0.0",
+    description: "Rempts Launcher Playground CLI",
+  },
+  onCmdStart() {
+    relinka("success", "Setup");
+  },
+  onCmdEnd() {
+    relinka("success", "Cleanup");
+  },
+  subCommands: {
+    build: () => import("./app/build/cmd.js").then((r) => r.default),
+    deploy: () => import("./app/deploy/cmd.js").then((r) => r.default),
+    debug: () => import("./app/debug/cmd.js").then((r) => r.default),
+  },
+});
 
-**Usage Example:**
+await runMain(main);
+```
 
 ```ts
 await runMain(myCommand, {
   fileBasedCmds: {
     enable: true,
-    cmdsRootPath: "./cli/args",
+    cmdsRootPath: "my-cmds", // default is `./app`
   },
   // Optionally disable auto-exit to handle errors manually:
   autoExit: false,
@@ -73,11 +179,12 @@ await runMain(myCommand, {
 
 This flexibility allows you to easily build a rich, multi-command CLI with minimal boilerplate. The launcher even supports nested subcommands, making it simple to construct complex CLI applications.
 
-### File-Based Subcommands
+#### File-Based Subcommands
 
-Drop a `./src/cli/args/add/index.ts` and it's live.
+Drop a `./src/cli/app/add/index.ts` and it's live.
 
 ```ts
+import { defineArgs, defineCommand } from "@reliverse/rempts";
 export default defineCommand({
   meta: {
     name: "add",
@@ -85,11 +192,11 @@ export default defineCommand({
     description: "Add stuff to your project",
   },
   args: {
-    name: {
+    name: defineArgs({ // 💡 PRO TIP: use defineArgs() to get fully correct intellisense
       type: "string",
       required: true,
       description: "Name of what to add",
-    },
+    }),
   },
   async run({ args }) {
     relinka("info", "Adding:", args.name);
@@ -106,22 +213,10 @@ export default defineCommand({
 
 **Hint**:
 
-- Install `bun i -g @reliverse/rempts-cli`
-- Use `rempts init --cmd my-cmd-1 my-cmd-2` to init commands automatically
-
-## 📦 Built-In Prompts
+- Install `bun add -D @reliverse/dler`
+- Use `dler init --cmd cmd1 cmd2` to init commands for rempts launcher's automatically
 
-- 🧠 `inputPrompt` – Single-line, password, masked
-- ✅ `selectPrompt` – Radio menu
-- 🧰 `multiselectPrompt` – Checkbox menu
-- 🔢 `numberPrompt` – Type-safe number input
-- 🔄 `confirmPrompt` – Yes/No toggle
-- 🚥 `togglePrompt` – Custom on/off toggles
-- ⏳ `spinnerPrompt` – Async loaders with status
-- 📜 `logPrompt` – Styled logs / steps
-- 🧼 `clearPrompt` – Clears console with style
-
-## 🧱 Minimal, Functional API
+### Advanced Minimal API
 
 ```ts
 defineCommand({
@@ -144,14 +239,14 @@ defineCommand({
 - Default values, validations, descriptions
 - Full help rendering from metadata
 
-## Theming + Customization
+### Theming + Customization
 
 - Built-in output formatter and logger
 - Override styles via prompt options
 - Smart layout for small terminals
 - Looks great in plain scripts or full CLI apps
 
-## Playground
+### Playground
 
 ```bash
 bun i -g @reliverse/rempts-cli
@@ -170,7 +265,42 @@ bun dev # supported options: name
 - Both `rempts examples` from @reliverse/rempts and `bun dev` (which is the same thing) are themselves examples of `launcher` functionality.
 - This launcher will show you a `multiselectPrompt()` where you can choose which CLI prompts you want to play with.
 
-### Minimal Usage Example
+### Launcher Usage Examples
+
+#### Minimal Usage Example
+
+**1 Create a `src/mod.ts` file:**
+
+```ts
+import { runMain, defineCommand } from "@reliverse/rempts";
+
+await runMain(defineCommand({}));
+```
+
+**2 Run the following:**
+
+```bash
+bun add -D @reliverse/dler # or: bun i -g @reliverse/dler
+bun dler init --cmd my-cmd-1 # or: dler init my-cmd-1 my-cmd-2 --main src/mod.ts
+# * `--main` is optional, default is `./src/mod.ts`
+# * you can specify multiple commands at once
+```
+
+**3 Visit `src/app/my-cmd-1/mod.ts` and edit it:**
+
+```ts
+export default defineCommand({
+  run() { console.log("Hello, world!"); },
+});
+```
+
+**4. Test it:**
+
+```bash
+bun src/mod.ts
+```
+
+#### Medium Usage Example
 
 ```ts
 import { defineCommand, runMain } from "@reliverse/rempts";
@@ -187,7 +317,7 @@ const main = defineCommand({
 await runMain(main);
 ```
 
-### Medium Usage Example
+#### Classic Usage Example
 
 ```ts
 import { relinka } from "@reliverse/relinka";
@@ -209,18 +339,18 @@ const main = defineCommand({
   args: {
     name: {
       type: "string",
-      required: false,
+      required: true,
       description: "The name of the project",
     },
   },
   async run({ args }) {
     await startPrompt({
-      title: "🚀 Project Setup",
+      title: "Project Setup",
     });
 
     const name = await inputPrompt({
       title: "What's your project name?",
-      placeholder: args.name ?? "my-cool-cli",
+      placeholder: args.name,
     });
 
     const framework = await selectPrompt({
@@ -239,7 +369,7 @@ const main = defineCommand({
 await runMain(main);
 ```
 
-### Advanced Usage Example
+#### Advanced Usage Example
 
 ```ts
 import { relinka } from "@reliverse/relinka";
@@ -258,7 +388,7 @@ import {
  * This command demonstrates the full range of launcher features along with all supported argument types:
  *
  * - Global Usage Handling: Automatically processes `--help` and `--version`.
- * - File-Based Subcommands: Scans "src/cli/args" for subcommands (e.g., `init`).
+ * - File-Based Subcommands: Scans "app" for subcommands (e.g., `init`).
  * - Comprehensive Argument Parsing: Supports positional, boolean, string, number, and array arguments.
  * - Interactive Prompts: Uses built-in prompt functions for an engaging CLI experience.
  */
@@ -273,12 +403,10 @@ const mainCommand = defineCommand({
     // Positional arguments
     inputFile: {
       type: "positional",
-      required: false,
       description: "Path to the input file (only for the main command).",
     },
     config: {
       type: "positional",
-      required: false,
       description: "Path to the configuration file.",
     },
     // Boolean arguments
@@ -295,20 +423,17 @@ const mainCommand = defineCommand({
     // String argument
     name: {
       type: "string",
-      required: false,
       description: "The name of the project.",
     },
     // Number argument
     timeout: {
       type: "number",
-      required: false,
       default: 30,
       description: "Timeout in seconds for the CLI operation.",
     },
     // Array argument
     tags: {
       type: "array",
-      required: false,
       default: ["cli", "rempts"],
       description: "List of tags associated with the project.",
     },
@@ -322,7 +447,7 @@ const mainCommand = defineCommand({
 
     // Begin interactive session with a prompt.
     await startPrompt({
-      title: "🚀 Project Setup",
+      title: "Project Setup",
     });
 
     // Ask for the project name, falling back to provided argument or a default.
@@ -358,7 +483,7 @@ const mainCommand = defineCommand({
 /**
  * The `runMain()` function sets up the launcher with several advanced features:
  *
- * - File-Based Subcommands: Enables scanning for subcommands within the "src/cli/args" directory.
+ * - File-Based Subcommands: Enables scanning for subcommands within the "app" directory.
  * - Alias Mapping: Shorthand flags (e.g., `-v`) are mapped to their full names (e.g., `--verbose`).
  * - Strict Mode & Unknown Flag Warnings: Unknown flags are either warned about or handled via a callback.
  * - Negated Boolean Support: Allows flags to be negated (e.g., `--no-verbose`).
@@ -367,7 +492,7 @@ const mainCommand = defineCommand({
 await runMain(mainCommand, {
   fileBasedCmds: {
     enable: true, // Enables file-based subcommand detection.
-    cmdsRootPath: "src/cli/args", // Directory to scan for subcommands.
+    cmdsRootPath: "app", // Directory to scan for subcommands.
   },
   alias: {
     v: "verbose", // Maps shorthand flag -v to --verbose.
@@ -382,6 +507,97 @@ await runMain(mainCommand, {
 });
 ```
 
+### CLI Launcher (Router)
+
+Finally, a full-featured CLI launcher without the ceremony. `@reliverse/rempts`'s so called "launcher" is a uniquely powerful and ergonomic CLI toolkit—one that helps you build delightful developer experiences with less code and more confidence. The launcher supports both programmatically defined subcommands and file-based routing, so you can structure your CLI however you like. It automatically detects and loads subcommands from your filesystem and provides robust usage and error handling out-of-the-box. The launcher is more than just a command runner—it's a robust, developer-friendly engine with several advanced features and thoughtful design choices:
+
+- **File-Based & Defined Subcommands:**  
+  Use `subCommands` in your command definition or let the launcher automatically load commands from a specified directory.
+
+- **Automatic Command Detection:**  
+  The launcher scans your specified `cmdsRootPath` for command files matching common patterns such as:
+  - `arg-cmdName.{ts,js}`
+  - `cmdName/index.{ts,js}`
+  - `cmdName/cmdName-mod.{ts,js}`
+  - And more — with automatic usage output if a command file is not found.
+
+- **Built-In Flag Handling:**  
+  Automatically processes global flags such as:
+  - `--help` and `-h` to show usage details.
+  - `--version` and `-v` to display version information.
+  - `--debug` for verbose logging during development.
+
+- **Unified Argument Parsing:**  
+  Seamlessly combines positional and named arguments with zero configuration, auto-parsing booleans, strings, numbers, arrays, and even supporting negated flags like `--no-flag`.
+
+- **Customizable Behavior:**  
+  Options such as `fileBasedCmds.enable`, `cmdsRootPath`, and `autoExit` allow you to tailor the launcher's behavior. For example, you can choose whether the process should exit automatically on error or allow manual error handling.
+
+- **Error Management & Usage Output:**  
+  The launcher provides clear error messages for missing required arguments, invalid types, or command import issues, and it automatically displays usage information for your CLI.
+
+- **Lifecycle Hooks:**
+  You can define optional lifecycle hooks in your main command:
+  - `onLauncherStart` and `onLauncherEnd` (global, called once per CLI process)
+  - `onCmdStart` and `onCmdEnd` (per-subcommand, called before/after each subcommand, but NOT for the main `run()` handler)
+
+  **Global Hooks:**
+  - `onLauncherStart`: Called once, before any command/subcommand/run() is executed.
+  - `onLauncherEnd`: Called once, after all command/subcommand/run() logic is finished (even if an error occurs).
+
+  **Per-Subcommand Hooks:**
+  - `onCmdStart`: Called before each subcommand (not for main `run()`).
+  - `onCmdEnd`: Called after each subcommand (not for main `run()`).
+
+  This means:
+  - If your CLI has multiple subcommands, `onCmdStart` and `onCmdEnd` will be called for each subcommand invocation, not just once for the whole CLI process.
+  - If your main command has a `run()` handler (and no subcommand is invoked), these hooks are **not** called; use the `run()` handler itself or the global hooks for such logic.
+  - This allows you to perform setup/teardown logic specific to each subcommand execution.
+  - If you want logic to run only once for the entire CLI process, use `onLauncherStart` and `onLauncherEnd`.
+
+  **Example:**
+
+  ```ts
+  const main = defineCommand({
+    onLauncherStart() { relinka('info', 'Global setup (once per process)'); },
+    onLauncherEnd() { relinka('info', 'Global cleanup (once per process)'); },
+    onCmdStart() { relinka('info', 'Setup for each subcommand'); },
+    onCmdEnd() { relinka('info', 'Cleanup for each subcommand'); },
+    subCommands: { ... },
+    run() { relinka('info', 'Main run handler (no subcommand)'); },
+  });
+  // onLauncherStart/onLauncherEnd are called once per process
+  // onCmdStart/onCmdEnd are called for every subcommand (not for main run())
+  // If you want per-run() logic, use the run() handler or global hooks
+  ```
+
+  > **Note:** The legacy `setup` and `cleanup` names are still supported as aliases for per-command hooks, but will be removed in a future major version. Prefer `onCmdStart` and `onCmdEnd` going forward.
+
+- **Dynamic Usage Examples:**
+  - The launcher inspects your available subcommands and their argument definitions, then prints a plausible example CLI invocation for a random subcommand directly in the help output. This helps users understand real-world usage at a glance.
+
+- **File-Based & Programmatic Subcommands:**
+  - Both file-based and object subcommands are fully supported. The launcher can introspect their argument definitions and metadata for help, usage, and validation.
+  - File-based subcommands are auto-discovered from your filesystem, while programmatic subcommands can be defined inline in your main command.
+
+- **Context-Aware Help Output:**
+  - The help/usage output adapts to your CLI's structure, showing available subcommands, their aliases, argument details, and even dynamic usage examples. It also displays global options and context-specific error messages.
+
+- **Error Handling:**
+  - The launcher provides clear, actionable error messages for missing required arguments, invalid types, unknown commands, and import errors. It always shows relevant usage information to help users recover quickly.
+
+- **Unified Argument Parsing:**
+  - All arguments (positional, named, boolean, string, number, array) are parsed and validated automatically. Negated flags (like `--no-flag`) are supported out of the box.
+
+- **Extensible & Flexible:**
+  - The launcher is highly extensible. You can use it with both Bun and Node.js, and it works seamlessly with both file-based and programmatic command definitions. You can also customize its behavior with options like `autoExit`, `cmdsRootPath`, and more.
+
+- **Bun & Node.js Support:**
+  - The launcher is designed to work in both Bun and Node.js environments, so you can use it in any modern JavaScript/TypeScript project.
+
+- **Prompt-First, Modern UX:**
+  - The launcher integrates tightly with the prompt engine, so you can build interactive, delightful CLIs with minimal effort.
+
 ## Contributing
 
 Bug report? Prompt idea? Want to build the best DX possible?
@@ -394,6 +610,24 @@ You're in the right place:
 
 > *No classes. No magic. Just clean, composable tools for CLI devs.*
 
+### Notices For Contributors
+
+**TypeScript Support**:
+
+All APIs are fully typed. See [`src/types.ts`](./src/types.ts) for advanced customization and type inference.
+
+**Examples**:
+
+- **Classic CLI:** [`example/launcher/classic.ts`](./example/launcher/classic.ts)
+- **Modern Minimal CLI:** [`example/launcher/modern.ts`](./example/launcher/modern.ts)
+- **Full Prompt Demo:** [`example/prompts/mod.ts`](./example/prompts/mod.ts)
+
+**Components and Utilities**:
+
+- **components/**: All prompt UIs, CLI output, launcher logic, etc.
+- **utils/**: Color, error, validation, streaming, and system helpers.
+- **hooks/**: Useful hooks for prompt state and effects.
+
 ### Helpful Links
 
 - [CLI application with the Node.js Readline module](https://dev.to/camptocamp-geo/cli-application-with-the-nodejs-readline-module-48ic)

package/bin/{core-impl → components}/anykey/anykey-mod.d.ts

@@ -1,4 +1,4 @@
-import type { ColorName } from "../../core-types.js";
+import type { ColorName } from "../../types.js";
 type Options = {
     ctrlC?: number | false | "reject";
     preserveLog?: boolean;

package/bin/{core-impl → components}/anykey/anykey-mod.js

@@ -2,7 +2,7 @@ import logUpdate from "log-update";
 import { cursor } from "sisteransi";
 import { fmt } from "../msg-fmt/messages.js";
 import { endPrompt } from "../st-end/end.js";
-import { streamText } from "../utils/stream-text.js";
+import { streamText } from "../../utils/stream-text.js";
 const DEFAULT_MESSAGE = "Press any key to continue...";
 const CTRL_C_CODE = 3;
 const terminal = {

package/bin/{core-impl → components}/date/date.d.ts

@@ -1,2 +1,2 @@
-import type { DatePromptOptions } from "../../core-types.js";
+import type { DatePromptOptions } from "../../types.js";
 export declare function datePrompt(opts: DatePromptOptions): Promise<string>;

package/bin/{core-impl → components}/editor/editor-mod.d.ts

@@ -1,4 +1,4 @@
-import type { EditorExitResult } from "../../core-types.js";
+import type { EditorExitResult } from "../../types.js";
 type EditorConfig = {
     syntaxHighlighting?: boolean;
     theme?: "auto" | "light" | "dark";

package/bin/{core-impl → components}/editor/editor-mod.js

@@ -43,11 +43,11 @@ let state = {
   theme: {
     // Default Light Theme
     text: (str) => str,
-    statusBarBg: (str) => re.bgGray(str),
+    statusBarBg: (str) => re.bgBrown(str),
     statusBarText: (str) => re.white(str),
-    highlight: (str) => re.invert(str),
+    highlight: (str) => re.bgYellow(re.black(str)),
     // For search results, etc.
-    lineNumber: (str) => re.gray(str)
+    lineNumber: (str) => re.blue(str)
   },
   syntaxHighlightToggle: false,
   // Toggled state for syntax highlighting
@@ -91,7 +91,7 @@ function setupTheme(configTheme) {
   } else {
     state.theme = {
       text: (str) => re.black(str),
-      statusBarBg: (str) => re.bgGray(str),
+      statusBarBg: (str) => re.bgBrown(str),
       statusBarText: (str) => re.white(str),
       highlight: (str) => re.bgCyan(re.black(str)),
       lineNumber: (str) => re.gray(str)
@@ -808,10 +808,10 @@ async function initializeEditorState(options) {
     state.theme = {
       // Reset theme based on config
       text: (str) => str,
-      statusBarBg: (str) => re.bgGray(str),
+      statusBarBg: (str) => re.bgBrown(str),
       statusBarText: (str) => re.white(str),
-      highlight: (str) => re.invert(str),
-      lineNumber: (str) => re.gray(str)
+      highlight: (str) => re.bgYellow(re.black(str)),
+      lineNumber: (str) => re.blue(str)
     };
     setupTheme(state.editorConfig.theme);
   } catch (error) {

package/bin/{core-impl → components}/input/confirm-prompt.d.ts

@@ -1,4 +1,4 @@
-import type { ConfirmPromptOptions } from "../../core-types.js";
+import type { ConfirmPromptOptions } from "../../types.js";
 /**
  * Prompts the user with a yes/no question, returning a boolean based on their input.
  */

package/bin/{core-impl → components}/input/confirm-prompt.js

@@ -3,7 +3,7 @@ import { stdin as input, stdout as output } from "node:process";
 import readline from "node:readline/promises";
 import { bar, msg } from "../msg-fmt/messages.js";
 import { deleteLastLine } from "../msg-fmt/terminal.js";
-import { completePrompt } from "../utils/prompt-end.js";
+import { completePrompt } from "../../utils/prompt-end.js";
 function renderPrompt(params) {
   const {
     title,

package/bin/{core-impl → components}/input/input-prompt.d.ts

@@ -1,4 +1,4 @@
-import type { InputPromptOptions } from "../../core-types.js";
+import type { InputPromptOptions } from "../../types.js";
 /**
  * inputPrompt()
  *