smart-passphrase 1.0.2 → 2.0.1

package/README.md

@@ -1,44 +1,52 @@
+Human-readable, secure password generator for developers and CLI usage.
 # smart-passphrase
 
 A lightweight, secure, and memorable passphrase generator for Node.js and modern browsers. Built to work smoothly in React, Next.js, Vite, and plain Node projects.
 
 ## Features
-- Human‑readable passphrases with strong randomness
-- Cryptographically secure randomness (via `crypto.getRandomValues`)
-- Works in React, Next.js, Vite, and Node 18+
-- Fully typed TypeScript API
-- Configurable casing, symbols, numbers, and word patterns
-- Custom dictionary support
+- **Memorable**: Human‑readable passphrases that are easy to type and remember.
+- **Secure**: Uses cryptographically secure randomness (via `crypto.getRandomValues`).
+- **Versatile**: Works in React, Next.js, Vite, and Node 18+.
+- **Premium CLI**: Beautifully styled terminal output with colors and animations.
+- **Clipboard Support**: Copy passphrases instantly from the CLI.
+- **Zero Dependencies (Core)**: Only adds dependencies for the CLI tool.
+- **Fully Typed**: Written in TypeScript with a complete API.
 
 ## Install
 ```bash
 npm install smart-passphrase
 ```
 
-## Quick Start
-```ts
-import { generatePassphrase } from "smart-passphrase";
-
-const passphrase = generatePassphrase();
-console.log(passphrase);
+## Quick Start (Terminal)
+Generate a passphrase instantly with a premium experience:
+```bash
+npx smart-passphrase
 ```
 
-## Example Output
+**Pro Tip (Copy to clipboard):**
+```bash
+npx smart-passphrase copy
+# or
+npx smart-passphrase -c
 ```
-SilentGOOSE^mark324
-BrAveTiger#run891
-quickROCKET=jump472
+
+**Custom Strength:**
+```bash
+npx smart-passphrase --strength ultra
 ```
 
-## Usage in React / Next.js / Vite
-```tsx
+## Quick Start (Code)
+```ts
 import { generatePassphrase } from "smart-passphrase";
 
-export default function App() {
-  return <h2>{generatePassphrase()}</h2>;
-}
+const passphrase = generatePassphrase();
+console.log(passphrase);
+// Output: SilentGOOSE^mark324
 ```
 
+## Example Output
+The CLI provides a vibrant, gradient-colored output that stands out!
+
 ## API
 
 ### `generatePassphrase(options?)`
@@ -71,102 +79,48 @@ const bits = entropyEstimate({ words: 4, symbols: true, numbers: true });
 ## Options
 
 ### `words`
-Number of word tokens in the passphrase.
-
-```ts
-generatePassphrase({ words: 4 });
-```
+Number of word tokens in the passphrase. Default is `3`.
 
 ### `numbers`
-- `true` (default) to add digits
-- `{ digits: number }` to control length
-
-```ts
-generatePassphrase({ numbers: { digits: 4 } });
-```
+- `true` (default): Adds digits.
+- `{ digits: number }`: Controls the number of digits.
+- `false`: Removes digits.
 
 ### `symbols`
-- `true` (default) to include symbols
-- `string[]` to provide your own symbol list
-
-```ts
-generatePassphrase({ symbols: ["$", "-", "_"] });
-```
+- `true` (default): Includes one random symbol.
+- `string[]`: Provide your own symbol list to pick from.
+- `false`: Removes symbols.
 
 ### `uppercaseStyle`
-Controls casing:
-
-```ts
-"none" | "random" | "title" | "upper" | "lower"
-```
-
-Example:
-```ts
-generatePassphrase({ uppercaseStyle: "title" });
-```
-
-### `separator`
-String inserted between all parts.
-
-```ts
-generatePassphrase({ separator: "-" });
-```
-
-### `unique`
-Avoid repeating words within the same passphrase.
-
-```ts
-generatePassphrase({ unique: true });
-```
+Controls casing style for the words:
+`"none" | "random" | "title" | "upper" | "lower"`
 
 ### `strength`
-Preset security tiers:
-
-```ts
-"medium" | "strong" | "ultra"
-```
-
-Each tier increases words, digits, and entropy.
+Preset security tiers that adjust words, symbols, and digits.
 
-```ts
-generatePassphrase({ strength: "ultra" });
-```
+| Tier | Words | Symbols | Digits | Approx. Entropy |
+| :--- | :--- | :--- | :--- | :--- |
+| `medium` | 3 | Yes | 3 | ~45-50 bits |
+| `strong` | 4 | Yes | 4 | ~60-70 bits |
+| `ultra` | 5 | Yes | 5 | ~80+ bits |
 
-### `pattern`
-Custom order of word types.
-
-```ts
-generatePassphrase({ pattern: ["adj", "noun", "verb"] });
-```
-
-Available word kinds:
-```ts
-"adj" | "noun" | "verb"
-```
+## CLI Reference
+Run `npx smart-passphrase [command] [options]` or install globally.
 
-### `dictionary`
-Override the default word lists.
+### Commands
+- `[default]` - Generate a passphrase.
+- `copy` - Generate and copy to clipboard immediately.
 
-```ts
-generatePassphrase({
-  dictionary: {
-    adjectives: ["silent", "rapid"],
-    nouns: ["fox", "river"],
-    verbs: ["glide", "spark"]
-  }
-});
-```
+### Options
+- `-w, --words <n>` - Set the number of words (default: 3).
+- `-s, --strength <tier>` - Set tier (medium, strong, ultra).
+- `-c, --copy` - Copy generated passphrase to clipboard.
+- `-n, --no-numbers` - Disable numbers.
+- `-S, --no-symbols` - Disable symbols.
 
 ## Security Notes
 - Uses `crypto.getRandomValues` for strong randomness.
 - Requires Node 18+ or a modern browser runtime.
-- For even higher entropy, increase `words`, `digits`, or use `strength: "ultra"`.
 
 ## License
-MIT
-```
-
-If you want, I can also add:
-1. A `COPY` helper utility example
-2. A CLI usage snippet
-3. A comparison table for `strength` presets
+MIT

package/dist/cjs/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const clipboardy_1 = __importDefault(require("clipboardy"));
+const gradient_string_1 = __importDefault(require("gradient-string"));
+const generator_js_1 = require("./generator.js");
+const program = new commander_1.Command();
+program
+    .name("smart-passphrase")
+    .description("Generate secure and memorable passphrases with style")
+    .version("2.0.0")
+    .option("-w, --words <number>", "number of words", (val) => parseInt(val), 3)
+    .option("-s, --strength <tier>", "security tier (medium, strong, ultra)", "medium")
+    .option("-n, --no-numbers", "do not include numbers")
+    .option("-S, --no-symbols", "do not include symbols")
+    .option("-c, --copy", "copy to clipboard")
+    .action(async (options) => {
+    console.log("");
+    const spinner = (0, ora_1.default)({
+        text: chalk_1.default.cyan("Locking the gears..."),
+        color: "cyan"
+    }).start();
+    // Small delay for "fancy" feel
+    await new Promise((resolve) => setTimeout(resolve, 600));
+    try {
+        const password = (0, generator_js_1.generatePassword)({
+            words: options.words,
+            strength: options.strength,
+            numbers: options.numbers,
+            symbols: options.symbols,
+        });
+        spinner.succeed(chalk_1.default.green("Secure passphrase ready!"));
+        console.log("");
+        const styledPassword = gradient_string_1.default.pastel.multiline(password);
+        console.log("  " + chalk_1.default.bold(styledPassword));
+        console.log("");
+        if (options.copy) {
+            clipboardy_1.default.writeSync(password);
+            console.log(chalk_1.default.dim("  📋 Copied to clipboard!"));
+            console.log("");
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red("Generation failed"));
+        console.error(chalk_1.default.red(`  Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+// Handle the "copy" as a shorthand command too
+program
+    .command("copy")
+    .description("Generate and copy to clipboard immediately")
+    .action(async () => {
+    const spinner = (0, ora_1.default)(chalk_1.default.cyan("Generating and copying...")).start();
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    const password = (0, generator_js_1.generatePassword)();
+    clipboardy_1.default.writeSync(password);
+    spinner.succeed(chalk_1.default.green("Generated and copied to clipboard!"));
+    console.log("");
+    console.log("  " + gradient_string_1.default.pastel(password));
+    console.log("");
+});
+program.parse();

package/dist/cjs/generator.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generatePassphrase = generatePassphrase;
 exports.generatePassword = generatePassword;
 exports.entropyEstimate = entropyEstimate;
-const wordlist_1 = require("./wordlist");
-const utils_1 = require("./utils");
+const wordlist_js_1 = require("./wordlist.js");
+const utils_js_1 = require("./utils.js");
 const strengthDefaults = {
     medium: { words: 3, symbols: true, digits: 3 },
     strong: { words: 4, symbols: true, digits: 4 },
@@ -12,9 +12,9 @@ const strengthDefaults = {
 };
 function buildDictionary(overrides) {
     return {
-        adjectives: overrides?.adjectives ?? wordlist_1.adjectives,
-        nouns: overrides?.nouns ?? wordlist_1.nouns,
-        verbs: overrides?.verbs ?? wordlist_1.verbs
+        adjectives: overrides?.adjectives ?? wordlist_js_1.adjectives,
+        nouns: overrides?.nouns ?? wordlist_js_1.nouns,
+        verbs: overrides?.verbs ?? wordlist_js_1.verbs
     };
 }
 function chooseWords(dictionary, kinds, unique) {
@@ -25,11 +25,11 @@ function chooseWords(dictionary, kinds, unique) {
         if (list.length === 0) {
             throw new Error(`Dictionary list for ${kind} is empty`);
         }
-        let picked = (0, utils_1.randomItem)(list);
+        let picked = (0, utils_js_1.randomItem)(list);
         if (unique) {
             let attempts = 0;
             while (used.has(picked) && attempts < 25) {
-                picked = (0, utils_1.randomItem)(list);
+                picked = (0, utils_js_1.randomItem)(list);
                 attempts += 1;
             }
         }
@@ -60,17 +60,17 @@ function generatePassphrase(options = {}) {
     if (pattern.length !== wordCount) {
         throw new Error("pattern length must match words");
     }
-    const words = chooseWords(dictionary, pattern, unique).map((word) => (0, utils_1.applyCase)(word, uppercaseStyle));
+    const words = chooseWords(dictionary, pattern, unique).map((word) => (0, utils_js_1.applyCase)(word, uppercaseStyle));
     const parts = [];
     for (const word of words) {
         parts.push(word);
     }
     if (useSymbols) {
-        const symbols = Array.isArray(useSymbols) ? useSymbols : utils_1.defaultSymbols;
-        parts.push((0, utils_1.randomItem)(symbols));
+        const symbols = Array.isArray(useSymbols) ? useSymbols : utils_js_1.defaultSymbols;
+        parts.push((0, utils_js_1.randomItem)(symbols));
     }
     if (numbersOption) {
-        parts.push(String((0, utils_1.randomNumberByDigits)(digits)));
+        parts.push(String((0, utils_js_1.randomNumberByDigits)(digits)));
     }
     if (separator) {
         return parts.join(separator);
@@ -93,7 +93,7 @@ function entropyEstimate(options = {}) {
         return list.length || 1;
     });
     const wordSpace = sizes.reduce((acc, size) => acc * size, 1);
-    const symbolSpace = useSymbols ? (Array.isArray(useSymbols) ? useSymbols.length : utils_1.defaultSymbols.length) : 1;
+    const symbolSpace = useSymbols ? (Array.isArray(useSymbols) ? useSymbols.length : utils_js_1.defaultSymbols.length) : 1;
     const numberSpace = numbersOption ? Math.pow(10, digits) : 1;
     const total = wordSpace * symbolSpace * numberSpace;
     return Math.log2(total);

package/dist/cjs/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.entropyEstimate = exports.generatePassword = exports.generatePassphrase = void 0;
-var generator_1 = require("./generator");
-Object.defineProperty(exports, "generatePassphrase", { enumerable: true, get: function () { return generator_1.generatePassphrase; } });
-Object.defineProperty(exports, "generatePassword", { enumerable: true, get: function () { return generator_1.generatePassword; } });
-Object.defineProperty(exports, "entropyEstimate", { enumerable: true, get: function () { return generator_1.entropyEstimate; } });
+var generator_js_1 = require("./generator.js");
+Object.defineProperty(exports, "generatePassphrase", { enumerable: true, get: function () { return generator_js_1.generatePassphrase; } });
+Object.defineProperty(exports, "generatePassword", { enumerable: true, get: function () { return generator_js_1.generatePassword; } });
+Object.defineProperty(exports, "entropyEstimate", { enumerable: true, get: function () { return generator_js_1.entropyEstimate; } });

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import clipboardy from "clipboardy";
+import gradient from "gradient-string";
+import { generatePassword } from "./generator.js";
+const program = new Command();
+program
+    .name("smart-passphrase")
+    .description("Generate secure and memorable passphrases with style")
+    .version("2.0.0")
+    .option("-w, --words <number>", "number of words", (val) => parseInt(val), 3)
+    .option("-s, --strength <tier>", "security tier (medium, strong, ultra)", "medium")
+    .option("-n, --no-numbers", "do not include numbers")
+    .option("-S, --no-symbols", "do not include symbols")
+    .option("-c, --copy", "copy to clipboard")
+    .action(async (options) => {
+    console.log("");
+    const spinner = ora({
+        text: chalk.cyan("Locking the gears..."),
+        color: "cyan"
+    }).start();
+    // Small delay for "fancy" feel
+    await new Promise((resolve) => setTimeout(resolve, 600));
+    try {
+        const password = generatePassword({
+            words: options.words,
+            strength: options.strength,
+            numbers: options.numbers,
+            symbols: options.symbols,
+        });
+        spinner.succeed(chalk.green("Secure passphrase ready!"));
+        console.log("");
+        const styledPassword = gradient.pastel.multiline(password);
+        console.log("  " + chalk.bold(styledPassword));
+        console.log("");
+        if (options.copy) {
+            clipboardy.writeSync(password);
+            console.log(chalk.dim("  📋 Copied to clipboard!"));
+            console.log("");
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Generation failed"));
+        console.error(chalk.red(`  Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+// Handle the "copy" as a shorthand command too
+program
+    .command("copy")
+    .description("Generate and copy to clipboard immediately")
+    .action(async () => {
+    const spinner = ora(chalk.cyan("Generating and copying...")).start();
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    const password = generatePassword();
+    clipboardy.writeSync(password);
+    spinner.succeed(chalk.green("Generated and copied to clipboard!"));
+    console.log("");
+    console.log("  " + gradient.pastel(password));
+    console.log("");
+});
+program.parse();

package/dist/generator.d.ts

@@ -1,4 +1,4 @@
-import type { GenerateOptions } from "./types";
+import type { GenerateOptions } from "./types.js";
 export declare function generatePassphrase(options?: GenerateOptions): string;
 export declare function generatePassword(options?: GenerateOptions): string;
 export declare function entropyEstimate(options?: GenerateOptions): number;

package/dist/generator.js

@@ -0,0 +1,95 @@
+import { adjectives, nouns, verbs } from "./wordlist.js";
+import { applyCase, defaultSymbols, randomItem, randomNumberByDigits } from "./utils.js";
+const strengthDefaults = {
+    medium: { words: 3, symbols: true, digits: 3 },
+    strong: { words: 4, symbols: true, digits: 4 },
+    ultra: { words: 5, symbols: true, digits: 5 }
+};
+function buildDictionary(overrides) {
+    return {
+        adjectives: overrides?.adjectives ?? adjectives,
+        nouns: overrides?.nouns ?? nouns,
+        verbs: overrides?.verbs ?? verbs
+    };
+}
+function chooseWords(dictionary, kinds, unique) {
+    const used = new Set();
+    const output = [];
+    for (const kind of kinds) {
+        const list = kind === "adj" ? dictionary.adjectives : kind === "noun" ? dictionary.nouns : dictionary.verbs;
+        if (list.length === 0) {
+            throw new Error(`Dictionary list for ${kind} is empty`);
+        }
+        let picked = randomItem(list);
+        if (unique) {
+            let attempts = 0;
+            while (used.has(picked) && attempts < 25) {
+                picked = randomItem(list);
+                attempts += 1;
+            }
+        }
+        used.add(picked);
+        output.push(picked);
+    }
+    return output;
+}
+function defaultPattern(words) {
+    const pool = ["adj", "noun", "verb"];
+    const output = [];
+    for (let i = 0; i < words; i += 1) {
+        output.push(pool[i % pool.length]);
+    }
+    return output;
+}
+export function generatePassphrase(options = {}) {
+    const defaults = options.strength ? strengthDefaults[options.strength] : strengthDefaults.medium;
+    const wordCount = options.words ?? defaults.words;
+    const useSymbols = options.symbols ?? defaults.symbols;
+    const numbersOption = options.numbers ?? true;
+    const digits = typeof numbersOption === "object" ? numbersOption.digits ?? defaults.digits : defaults.digits;
+    const separator = options.separator ?? "";
+    const uppercaseStyle = options.uppercaseStyle ?? "random";
+    const unique = options.unique ?? true;
+    const dictionary = buildDictionary(options.dictionary);
+    const pattern = options.pattern ?? defaultPattern(wordCount);
+    if (pattern.length !== wordCount) {
+        throw new Error("pattern length must match words");
+    }
+    const words = chooseWords(dictionary, pattern, unique).map((word) => applyCase(word, uppercaseStyle));
+    const parts = [];
+    for (const word of words) {
+        parts.push(word);
+    }
+    if (useSymbols) {
+        const symbols = Array.isArray(useSymbols) ? useSymbols : defaultSymbols;
+        parts.push(randomItem(symbols));
+    }
+    if (numbersOption) {
+        parts.push(String(randomNumberByDigits(digits)));
+    }
+    if (separator) {
+        return parts.join(separator);
+    }
+    return parts.join("");
+}
+export function generatePassword(options = {}) {
+    return generatePassphrase(options);
+}
+export function entropyEstimate(options = {}) {
+    const defaults = options.strength ? strengthDefaults[options.strength] : strengthDefaults.medium;
+    const wordCount = options.words ?? defaults.words;
+    const useSymbols = options.symbols ?? defaults.symbols;
+    const numbersOption = options.numbers ?? true;
+    const digits = typeof numbersOption === "object" ? numbersOption.digits ?? defaults.digits : defaults.digits;
+    const dictionary = buildDictionary(options.dictionary);
+    const pattern = options.pattern ?? defaultPattern(wordCount);
+    const sizes = pattern.map((kind) => {
+        const list = kind === "adj" ? dictionary.adjectives : kind === "noun" ? dictionary.nouns : dictionary.verbs;
+        return list.length || 1;
+    });
+    const wordSpace = sizes.reduce((acc, size) => acc * size, 1);
+    const symbolSpace = useSymbols ? (Array.isArray(useSymbols) ? useSymbols.length : defaultSymbols.length) : 1;
+    const numberSpace = numbersOption ? Math.pow(10, digits) : 1;
+    const total = wordSpace * symbolSpace * numberSpace;
+    return Math.log2(total);
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { generatePassphrase, generatePassword, entropyEstimate } from "./generator";
-export type { GenerateOptions, Dictionary, UppercaseStyle, Strength, WordKind } from "./types";
+export { generatePassphrase, generatePassword, entropyEstimate } from "./generator.js";
+export type { GenerateOptions, Dictionary, UppercaseStyle, Strength, WordKind } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { generatePassphrase, generatePassword, entropyEstimate } from "./generator.js";

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,51 @@
+export const defaultSymbols = ["@", "#", "^", "=", ")", "!", "*", "%"];
+export function secureRandomInt(maxExclusive) {
+    if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {
+        throw new Error("maxExclusive must be a positive integer");
+    }
+    const cryptoObj = globalThis.crypto;
+    if (!cryptoObj || typeof cryptoObj.getRandomValues !== "function") {
+        throw new Error("Secure crypto is not available in this environment");
+    }
+    const range = 0x100000000;
+    const limit = range - (range % maxExclusive);
+    const buf = new Uint32Array(1);
+    let value = 0;
+    do {
+        cryptoObj.getRandomValues(buf);
+        value = buf[0];
+    } while (value >= limit);
+    return value % maxExclusive;
+}
+export function randomItem(items) {
+    if (items.length === 0) {
+        throw new Error("Cannot choose from an empty list");
+    }
+    return items[secureRandomInt(items.length)];
+}
+export function randomBool() {
+    return secureRandomInt(2) === 1;
+}
+export function applyCase(word, style) {
+    if (style === "none")
+        return word;
+    if (style === "upper")
+        return word.toUpperCase();
+    if (style === "lower")
+        return word.toLowerCase();
+    if (style === "title")
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    return word
+        .split("")
+        .map((ch) => (randomBool() ? ch.toUpperCase() : ch.toLowerCase()))
+        .join("");
+}
+export function randomNumberByDigits(digits) {
+    if (!Number.isInteger(digits) || digits <= 0) {
+        throw new Error("digits must be a positive integer");
+    }
+    const min = Math.pow(10, digits - 1);
+    const max = Math.pow(10, digits) - 1;
+    const span = max - min + 1;
+    return min + secureRandomInt(span);
+}

package/dist/wordlist.js

@@ -0,0 +1,110 @@
+export const adjectives = [
+    // Original
+    "quick", "silent", "brave", "fancy", "eager", "bright",
+    "gentle", "proud", "curious", "steady", "bold", "calm",
+    // Advanced originals
+    "resilient", "ephemeral", "luminous", "tenacious", "serene",
+    "voracious", "ethereal", "stoic", "audacious", "fleeting",
+    "mellifluous", "incisive", "unyielding", "sublime", "transient",
+    "ferocious", "cunning", "reclusive", "radiant", "somber",
+    "deft", "keen", "vigilant", "nimble", "profound",
+    // New: memorial + solemn / meaningful tone
+    "memorial",
+    "immortal",
+    "reverent",
+    "hallowed",
+    "eternal",
+    "venerable",
+    "sacred",
+    "mournful",
+    "remnant",
+    "honored",
+    "legendary",
+    "fabled",
+    "timeless",
+    "perpetual",
+    "solemn",
+    "devoted",
+    "faithful",
+    "righteous",
+    "valiant",
+    "gallant",
+    "exalted",
+    "revered",
+    "venerated",
+    "undying",
+    "everlasting"
+];
+export const nouns = [
+    // Original
+    "tiger", "goose", "rocket", "mask", "forest", "ocean",
+    "ember", "comet", "cipher", "garden", "river", "mountain",
+    // Advanced originals
+    "phantom", "echo", "horizon", "sentinel", "abyss", "beacon",
+    "shroud", "monolith", "specter", "harbinger", "labyrinth",
+    "oracle", "crucible", "vigil", "rift", "veil", "tempest",
+    "solstice", "requiem", "synapse", "nexus", "axiom", "enigma",
+    "relic", "citadel",
+    // New: memorial + meaningful / legacy words
+    "memorial",
+    "monument",
+    "epitaph",
+    "shrine",
+    "tomb",
+    "grave",
+    "remembrance",
+    "legacy",
+    "heritage",
+    "echo",
+    "keepsake",
+    "memento",
+    "relic",
+    "vestige",
+    "tribute",
+    "offering",
+    "vow",
+    "oath",
+    "covenant",
+    "pillar",
+    "obelisk",
+    "chapel",
+    "sanctum",
+    "archive",
+    "chronicle"
+];
+export const verbs = [
+    // Original
+    "run", "jump", "build", "mark", "drift", "spark",
+    "forge", "glide", "shift", "trace", "craft", "sprint",
+    // Advanced originals
+    "lunge", "flicker", "shatter", "conceal", "summon", "evade",
+    "descend", "ascend", "sunder", "kindle", "lurk", "surge",
+    "fracture", "unravel", "coalesce", "sever", "ignite", "linger",
+    "plummet", "scatter", "converge", "diverge", "emanate", "sear", "wither",
+    // New: memorial / reverent / legacy actions
+    "honor",
+    "cherish",
+    "enshrine",
+    "lament",
+    "mourn",
+    "remember",
+    "immortalize",
+    "consecrate",
+    "dedicate",
+    "sanctify",
+    "preserve",
+    "bequeath",
+    "endure",
+    "inscribe",
+    "carve",
+    "engrave",
+    "invoke",
+    "recall",
+    "revere",
+    "venerate",
+    "exalt",
+    "glorify",
+    "commemorate",
+    "memorialize",
+    "pay homage"
+];

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "smart-passphrase",
-  "version": "1.0.2",
+  "version": "2.0.1",
   "description": "Memorable, secure passphrase generator for web and Node.",
   "license": "MIT",
   "author": "Ayush Solanki <ayushsolanki2901@gmail.com> (https://github.com/ayushsolanki29)",
   "type": "module",
-
   "repository": {
     "type": "git",
     "url": "https://github.com/ayushsolanki29/smart-passphrase"
   },
-
   "keywords": [
     "password",
     "passphrase",
@@ -18,29 +16,38 @@
     "security",
     "typescript"
   ],
-
+  "bin": {
+    "smart-passphrase": "./dist/cli.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/esm/index.js",
+      "import": "./dist/index.js",
       "require": "./dist/cjs/index.cjs"
     }
   },
-
   "main": "./dist/cjs/index.cjs",
-  "module": "./dist/esm/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "sideEffects": false,
-
   "scripts": {
     "build:esm": "tsc -p tsconfig.esm.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
     "build": "npm run build:esm && npm run build:cjs"
   },
-
   "devDependencies": {
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^25.6.0",
     "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "clipboardy": "^5.3.1",
+    "commander": "^14.0.3",
+    "gradient-string": "^3.0.0",
+    "ora": "^9.3.0"
   }
-}
+}