@nostrbox/cli 1.6.3 → 1.7.1

package/dist/commands/bip39zodiac/bip39zodiac.js

@@ -39,10 +39,186 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@nostrbox/core");
+const crypto_1 = require("crypto");
 const argParser_js_1 = require("../../utils/argParser.js");
+const cliHelpers_js_1 = require("../../utils/cliHelpers.js");
 const tabtab = __importStar(require("tabtab"));
 // Valid zodiac signs (converted to lowercase for CLI compatibility)
 const VALID_ZODIAC_SIGNS = core_1.ZODIAC_SIGNS.map((sign) => sign.toLowerCase());
+/**
+ * Derives encryption password from user-memorable parameters
+ *
+ * @param color - Color selection (blue, green, purple, etc.)
+ * @param birthday - Birthday day number (1-31)
+ * @param zodiacSign - Zodiac sign (Aries, Taurus, etc.)
+ * @param operation - Operation type (add or subtract)
+ * @returns Derived password string with format:
+ *          - ADD: UPPERCASE_COLOR + "+" + birthday + "+" + lowercase_zodiac (e.g., "BLUE+17+aries")
+ *          - SUBTRACT: lowercase_color + "-" + birthday + "-" + UPPERCASE_ZODIAC (e.g., "blue-17-ARIES")
+ */
+function deriveMemoryKeys(color, birthday, zodiacSign, operation) {
+    if (operation === 'add') {
+        return `${color.toUpperCase()}+${birthday}+${zodiacSign.toLowerCase()}`;
+    }
+    else {
+        return `${color.toLowerCase()}-${birthday}-${zodiacSign.toUpperCase()}`;
+    }
+}
+/**
+ * Generates random Base64 string of specified length
+ */
+function generateRandomBase64(length) {
+    const bytesNeeded = Math.ceil((length * 3) / 4);
+    const randomBytesBuffer = (0, crypto_1.randomBytes)(bytesNeeded);
+    const base64String = randomBytesBuffer.toString('base64');
+    return base64String.substring(0, length);
+}
+/**
+ * Splits an encrypted zodiac password into two parts based on birthday and color
+ *
+ * @param encryptedPassword - The encrypted zodiac password
+ * @param birthday - Birthday value (1-31)
+ * @param colorValue - Color value (1-7)
+ * @returns Two parts of same length as original, each containing partial original data
+ */
+function splitZodiacPassword(encryptedPassword, birthday, colorValue) {
+    const length = encryptedPassword.length;
+    const splitPoint = birthday + colorValue;
+    if (splitPoint >= length) {
+        throw new Error(`Split point (${splitPoint}) must be less than password length (${length})`);
+    }
+    // Part 1: First splitPoint chars from original + random garbage for rest
+    const part1Original = encryptedPassword.substring(0, splitPoint);
+    const part1Random = generateRandomBase64(length - splitPoint);
+    const part1 = part1Original + part1Random;
+    // Part 2: Random garbage for first splitPoint chars + remaining original chars
+    const part2Random = generateRandomBase64(splitPoint);
+    const part2Original = encryptedPassword.substring(splitPoint);
+    const part2 = part2Random + part2Original;
+    return {
+        part1,
+        part2,
+        splitPoint
+    };
+}
+/**
+ * Combines two split parts to recover the original encrypted zodiac password
+ *
+ * @param part1 - First split part
+ * @param part2 - Second split part
+ * @param birthday - Birthday value (1-31)
+ * @param colorValue - Color value (1-7)
+ * @returns Original encrypted zodiac password
+ */
+function combineZodiacPassword(part1, part2, birthday, colorValue) {
+    const splitPoint = birthday + colorValue;
+    if (part1.length !== part2.length) {
+        throw new Error(`Split parts must have same length (part1: ${part1.length}, part2: ${part2.length})`);
+    }
+    // Extract first splitPoint chars from part1
+    const firstPart = part1.substring(0, splitPoint);
+    // Extract remaining chars from part2
+    const secondPart = part2.substring(splitPoint);
+    return firstPart + secondPart;
+}
+// Color values mapping
+const COLOR_VALUES = {
+    blue: 1,
+    green: 2,
+    purple: 3,
+    orange: 4,
+    yellow: 5,
+    pink: 6,
+    brown: 7
+};
+const VALID_COLORS = Object.keys(COLOR_VALUES);
+/**
+ * Generates export JSON with encrypted split parts and all chain addresses
+ * Derives public addresses from the seed phrase for Bitcoin, Ethereum, Solana, TRON, and Nostr
+ */
+function generateExportData(seedPhrase, splitPart1, splitPart2, passphrase = '') {
+    const mnemonic = seedPhrase.join(' ');
+    // Derive Bitcoin native (bc1q...) address
+    const bitcoinResult = (0, core_1.deriveKeyFromMnemonic)({
+        mnemonic,
+        chain: 'bitcoin',
+        format: 'native',
+        passphrase,
+        accountIndex: 0,
+        changeIndex: 0,
+        addressIndex: 0
+    });
+    // Derive Nostr public key (npub1...)
+    const nostrResult = (0, core_1.deriveKeyFromMnemonic)({
+        mnemonic,
+        chain: 'nostr',
+        format: 'bech32',
+        passphrase,
+        accountIndex: 0,
+        changeIndex: 0,
+        addressIndex: 0
+    });
+    // Derive Ethereum address (0x...)
+    const ethereumResult = (0, core_1.deriveKeyFromMnemonic)({
+        mnemonic,
+        chain: 'ethereum',
+        format: 'native',
+        passphrase,
+        accountIndex: 0,
+        changeIndex: 0,
+        addressIndex: 0
+    });
+    // Derive Solana address
+    const solanaResult = (0, core_1.deriveKeyFromMnemonic)({
+        mnemonic,
+        chain: 'solana',
+        format: 'native',
+        passphrase,
+        accountIndex: 0
+    });
+    // Derive TRON address (T...)
+    const tronResult = (0, core_1.deriveKeyFromMnemonic)({
+        mnemonic,
+        chain: 'tron',
+        format: 'native',
+        passphrase,
+        accountIndex: 0,
+        changeIndex: 0,
+        addressIndex: 0
+    });
+    // Validate that all addresses were derived successfully
+    if (!bitcoinResult.address) {
+        throw new Error('Failed to derive Bitcoin address');
+    }
+    if (!nostrResult.publicKey) {
+        throw new Error('Failed to derive Nostr public key');
+    }
+    if (!ethereumResult.address) {
+        throw new Error('Failed to derive Ethereum address');
+    }
+    if (!solanaResult.address) {
+        throw new Error('Failed to derive Solana address');
+    }
+    if (!tronResult.address) {
+        throw new Error('Failed to derive TRON address');
+    }
+    return {
+        encZodiacPwdSplit1: splitPart1,
+        encZodiacPwdSplit2: splitPart2,
+        nostr: nostrResult.publicKey,
+        bitcoin: bitcoinResult.address,
+        ethereum: ethereumResult.address,
+        solana: solanaResult.address,
+        tron: tronResult.address
+    };
+}
+// Constants for format detection and validation
+const BASE58_PATTERN = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/;
+const MAX_ZODIAC_PASSWORD_LENGTH = 30;
+/**
+ * Creates and configures the argument parser for the CLI
+ * Defines all available flags, options, and their validation rules
+ */
 function createParser() {
     return new argParser_js_1.ArgumentParser({
         positional: {
@@ -53,14 +229,11 @@ function createParser() {
         options: [
             // Core mandatory flags
             {
-                name: 'red',
-                type: 'flag',
-                description: 'Red: add birthday offset (+) (mandatory: choose --red or --black)'
-            },
-            {
-                name: 'black',
-                type: 'flag',
-                description: 'Black: subtract birthday offset (-) (mandatory: choose --red or --black)'
+                name: 'operation',
+                alias: 'o',
+                type: 'string',
+                description: 'Operation type: add or subtract (mandatory)',
+                choices: ['add', 'subtract']
             },
             {
                 name: 'birthday',
@@ -75,6 +248,13 @@ function createParser() {
                 description: 'Zodiac sign for shuffling (mandatory)',
                 choices: [...VALID_ZODIAC_SIGNS]
             },
+            {
+                name: 'color',
+                alias: 'c',
+                type: 'string',
+                description: 'Color for additional offset: blue(1), green(2), purple(3), orange(4), yellow(5), pink(6), brown(7) (mandatory)',
+                choices: [...VALID_COLORS]
+            },
             // Main use cases
             {
                 name: 'restore',
@@ -94,15 +274,47 @@ function createParser() {
             },
             {
                 name: 'load',
+                type: 'flag',
+                description: 'Modifier flag: when used, data input flags expect file paths instead of direct values'
+            },
+            // Old import methods (for backward compatibility)
+            {
+                name: 'codes',
+                type: 'string',
+                description: 'Secret codes: provide numbers directly, or file path if --load is used'
+            },
+            {
+                name: 'zodiacPwd',
+                type: 'string',
+                description: 'Plain zodiac password: provide Base58 directly, or file path if --load is used'
+            },
+            {
+                name: 'encZodiacPwd',
                 type: 'string',
-                description: 'Load from file (seed phrase or numbers depending on --restore flag)'
+                description: 'Encrypted zodiac password: provide string directly, or file path if --load is used'
+            },
+            {
+                name: 'encZodiacPwdSplit',
+                type: 'string',
+                description: 'Encrypted split parts: provide comma-separated directly, or file path if --load is used'
+            },
+            // Encryption options
+            {
+                name: 'passphrase',
+                type: 'string',
+                description: 'Custom user password for encryption/decryption (overrides auto-derived memory keys)'
             },
             // Output format options
             {
                 name: 'zodiac-password',
                 alias: 'p',
                 type: 'flag',
-                description: 'Output/input zodiac password (Base58) instead of 12 numbers'
+                description: 'Output/input zodiac password (Base58, always encrypted and split) instead of 12 numbers'
+            },
+            {
+                name: 'export',
+                type: 'string',
+                description: 'Export JSON with encrypted split parts and public addresses to specified file'
             },
             // File options
             {
@@ -114,18 +326,24 @@ function createParser() {
         ]
     });
 }
+/**
+ * Sets up shell tab completion for the bip39zodiac command
+ * Provides intelligent autocomplete for flags, operations, zodiac signs, and colors
+ */
 async function setupCompletion(env) {
     // Handle completion request - return available options
     const flagCompletions = [
-        '--red',
-        '--black',
+        '--operation',
         '--birthday',
         '--zodiac',
+        '--color',
         '--new',
         '--seed',
         '--restore',
         '--load',
+        '--passphrase',
         '--zodiac-password',
+        '--export',
         '--save'
     ];
     const commandCompletions = ['install', 'uninstall'];
@@ -139,74 +357,84 @@ async function setupCompletion(env) {
             return tabtab.log(matches);
         }
     }
+    // Special case for operation values
+    const operationMatches = (0, cliHelpers_js_1.handleOptionValueCompletion)(env.line || '', current, 'operation', ['add', 'subtract']);
+    if (operationMatches) {
+        return tabtab.log(operationMatches);
+    }
     // Special case for zodiac values
-    if (env.line && env.line.includes('--zodiac=')) {
-        const zodiacPart = current.replace('--zodiac=', '');
-        const matches = VALID_ZODIAC_SIGNS.filter((sign) => sign.startsWith(zodiacPart));
-        return tabtab.log(matches);
+    const zodiacMatches = (0, cliHelpers_js_1.handleOptionValueCompletion)(env.line || '', current, 'zodiac', VALID_ZODIAC_SIGNS);
+    if (zodiacMatches) {
+        return tabtab.log(zodiacMatches);
+    }
+    // Special case for color values
+    const colorMatches = (0, cliHelpers_js_1.handleOptionValueCompletion)(env.line || '', current, 'color', VALID_COLORS);
+    if (colorMatches) {
+        return tabtab.log(colorMatches);
     }
     // Filter flag names based on current input
     const matches = flagCompletions.filter((comp) => comp.startsWith(current));
     return tabtab.log(matches);
 }
-async function installCompletion() {
-    try {
-        await tabtab.install({
-            name: 'bip39zodiac',
-            completer: 'bip39zodiac'
-        });
-        console.log('✅ Shell completion installed successfully!');
-        console.log('📝 You may need to restart your shell or run: source ~/.bashrc (or equivalent)');
-    }
-    catch (error) {
-        console.error('❌ Failed to install completion:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}
-async function uninstallCompletion() {
-    try {
-        await tabtab.uninstall({
-            name: 'bip39zodiac'
-        });
-        console.log('✅ Shell completion uninstalled successfully!');
-    }
-    catch (error) {
-        console.error('❌ Failed to uninstall completion:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}
+// Create shared completion installer and uninstaller using utility functions
+const installCompletion = (0, cliHelpers_js_1.createCompletionInstaller)('bip39zodiac');
+const uninstallCompletion = (0, cliHelpers_js_1.createCompletionUninstaller)('bip39zodiac');
 function showHelp() {
     console.log(`
 🌌 Seed Phrase CLI Tool - BIP39 Zodiac Operations
 
 USAGE:
-  bip39zodiac [INPUT_METHOD] [OPTIONS] [CONVERSION_FLAGS]
+  # Generation
+  bip39zodiac [GENERATION_INPUT] [CONVERSION_FLAGS] [OPTIONS]
+
+  # Restoration
+  bip39zodiac [RESTORE_INPUT] --restore [CONVERSION_FLAGS] [OPTIONS]
+
+  # Commands
   bip39zodiac <install|uninstall>
 
-INPUT METHODS (choose one):
+GENERATION INPUT METHODS (choose one):
   --new, -n                   Generate new random 12-word seed phrase
-  --seed "content"            Transform seed phrase or restore from codes  
-  --load <file>               Load from file (seed phrase or codes)
+  --seed "12 words"           Transform existing seed phrase (12 words directly)
+  --seed <file>               ... or file path when used with --load flag
 
-OPTIONS:
-  --restore                   Restore mode (reverses the transformation)
-  --zodiac-password, -p       Output/input zodiac password (Base58) instead of 12 numbers
-  --save <file>               Save results to file
+RESTORE INPUT METHODS (choose one, use with --restore):
+  --codes "numbers"                          Secret codes: provide numbers directly
+  --codes <file>                             ... or file path when used with --load flag
+  --zodiacPwd "base58"                       Plain zodiac password: provide Base58 directly
+  --zodiacPwd <file>                         ... or file path when used with --load flag
+  --encZodiacPwd "encrypted"                 Encrypted password: provide string directly
+  --encZodiacPwd <file>                      ... or file path when used with --load flag
+  --encZodiacPwdSplit "p1,p2"                Split parts: provide comma-separated directly
+  --encZodiacPwdSplit <file>                 ... or file path when used with --load flag (2 lines or 1 line with comma)
+  --load                                     Modifier flag: makes above flags expect file paths
 
 CONVERSION FLAGS (all required):
-  --red OR --black            Card color (exactly one required):
-    --red                     Add birthday offset (+)
-    --black                   Subtract birthday offset (-)
-  
-  --birthday <1-31>           Birthday day number (mandatory)
-  --zodiac <sign>             Zodiac sign for shuffling (mandatory)
+  --operation, -o <add|subtract>  Operation type (mandatory):
+    add                       Add offsets (+)
+    subtract                  Subtract offsets (-)
+
+  --birthday, -b <1-31>       Birthday day number (mandatory)
+  --zodiac, -z <sign>         Zodiac sign for shuffling (mandatory)
+  --color, -c <color>         Color for additional offset (mandatory):
+    blue(1), green(2), purple(3), orange(4), yellow(5), pink(6), brown(7)
+
+ENCRYPTION OPTIONS:
+  --passphrase <password>     Custom user password for encryption/decryption
+                              (overrides auto-derived memory keys)
+                              Requirements: min 8 chars, letters + numbers + special char,
+                              no common weak passwords (e.g., "password", "123456")
+
+OUTPUT OPTIONS:
+  --zodiac-password, -p       Output zodiac password (Base58) format
+  --export <file>             Export JSON with encrypted split parts and public addresses
+                              to specified file (Bitcoin, Ethereum, Solana, TRON, Nostr)
+  --save <file>               Save results to file
 
 COMMANDS:
   install                     Install shell completion for this command
   uninstall                   Uninstall shell completion for this command
 
-OPTIONS:
-
 ZODIAC SIGNS & ALGORITHMS:
   Original: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] - Original positions
   
@@ -223,43 +451,66 @@ ZODIAC SIGNS & ALGORITHMS:
   aquarius:    [3, 4, 5, 0, 1, 2, 9, 10, 11, 6, 7, 8]   - Swap segment pairs
   pisces:      [6, 7, 8, 9, 10, 11, 5, 4, 3, 2, 1, 0]   - Second half + mirrored first
 
-⚠️  WARNING: Use a family member's birthday, a celebritiy zodiac, or another memorable combination.
+⚠️  WARNING: Use a family member's birthday, a celebrity zodiac, or another memorable combination.
     Not your own birthday and zodiac for maximum security.
 
 EXAMPLES:
+  # GENERATION
   # Generate new seed phrase and transform it
-  bip39zodiac --new --red --birthday=17 --zodiac=aries
-  
-  # Transform existing seed phrase into codes and save
-  bip39zodiac --seed "abandon ability able..." --black --birthday=25 --zodiac=leo --save codes.txt
-  
-  # Transform to zodiac password (compact Base58 format)
-  bip39zodiac --seed "abandon ability able..." --red --birthday=10 --zodiac=virgo --zodiac-password
-  
-  # Load seed phrase from file and output zodiac password
-  bip39zodiac --load seedphrase.txt --red --birthday=10 --zodiac=virgo --zodiac-password --save password.txt
-  
-  # Restore original from codes (same color, auto-reverses) and save
-  bip39zodiac --seed "1234 567 890..." --restore --red --birthday=17 --zodiac=aries --save restored.txt
-  
-  # Restore from zodiac password
-  bip39zodiac --seed "AoWJhqGkNxEe2D" --restore --zodiac-password --black --birthday=25 --zodiac=leo
-  
-  # Load zodiac password from file to restore
-  bip39zodiac --load password.txt --restore --zodiac-password --red --birthday=10 --zodiac=virgo
-  
-  # Full workflow: transform to zodiac password and save, then restore
-  bip39zodiac --seed "abandon ability able..." --red --birthday=15 --zodiac=gemini --zodiac-password --save secret.txt
-  bip39zodiac --load secret.txt --restore --zodiac-password --red --birthday=15 --zodiac=gemini
+  bip39zodiac --new --operation=add --birthday=17 --zodiac=aries --color=blue
+
+  # Transform existing seed phrase and save
+  bip39zodiac --seed "abandon ability able..." --save codes.txt --operation=subtract --birthday=25 --zodiac=leo --color=green
+
+  # Load seed phrase from file and save with zodiac password format
+  bip39zodiac --load --seed seedphrase.txt --zodiac-password --save password.txt --operation=add --birthday=10 --zodiac=virgo --color=orange
+
+  # Generate with custom passphrase instead of memory keys
+  bip39zodiac --new --passphrase "MySecretPassword.123" --operation=add --birthday=17 --zodiac=aries --color=blue
+
+  # Export JSON with encrypted split parts and all chain addresses to file
+  bip39zodiac --new --export export.json --operation=add --birthday=17 --zodiac=aries --color=blue
+
+  # RESTORATION
+  # Restore from secret codes
+  bip39zodiac --restore --codes "22 23 24 25 26 27 28 29 30 19 20 21" --operation=add --birthday=17 --zodiac=aries --color=blue
+
+  # Restore from secret codes loaded from file
+  bip39zodiac --restore --load --codes codes.txt --operation=add --birthday=17 --zodiac=aries --color=blue
+
+  # Restore from plain zodiac password
+  bip39zodiac --restore --zodiacPwd "1P1Q1R1S1T1U1V1W1X1L1M1N" --operation=subtract --birthday=25 --zodiac=leo --color=yellow
+
+  # Restore from encrypted zodiac password (single string)
+  bip39zodiac --restore --encZodiacPwd "s2ubbiTDzq..." --operation=add --birthday=10 --zodiac=virgo --color=pink
+
+  # Restore from encrypted split parts
+  bip39zodiac --restore --encZodiacPwdSplit "part1...,part2..." --operation=add --birthday=15 --zodiac=gemini --color=brown
+
+  # Load codes from file and restore (--load makes --codes expect file path)
+  bip39zodiac --restore --load --codes codes.txt --operation=add --birthday=17 --zodiac=aries --color=blue
+
+  # Load encrypted split from file (2 lines or 1 line with comma)
+  bip39zodiac --restore --load --encZodiacPwdSplit password.txt --operation=add --birthday=10 --zodiac=virgo --color=orange
+
+  # Restore with custom passphrase
+  bip39zodiac --restore --encZodiacPwdSplit "part1...,part2..." --passphrase "MySecretPassword.123" --operation=add --birthday=15 --zodiac=gemini --color=brown
+
+  # INSTALL COMPLETION
+  bip39zodiac install
 `);
 }
+/**
+ * Validates that all core mandatory flags are present and have valid values
+ * Throws descriptive errors if any validation fails
+ */
 function validateCoreFlags(args) {
-    // Validate exactly one of red/black
-    if (!args.red && !args.black) {
-        throw new Error('Core flag required: exactly one of --red or --black must be specified');
+    // Validate operation
+    if (!args.operation) {
+        throw new Error('Core flag required: --operation <add|subtract> must be specified');
     }
-    if (args.red && args.black) {
-        throw new Error('Core flag conflict: cannot use both --red and --black');
+    if (args.operation !== 'add' && args.operation !== 'subtract') {
+        throw new Error('Operation must be either "add" or "subtract"');
     }
     // Validate birthday
     const birthdayArg = args.birthday;
@@ -274,125 +525,207 @@ function validateCoreFlags(args) {
     if (!args.zodiac) {
         throw new Error('Core flag required: --zodiac <sign> must be specified');
     }
+    // Validate color
+    if (!args.color) {
+        throw new Error('Core flag required: --color <blue|green|purple|orange|yellow|pink|brown> must be specified');
+    }
+    if (!VALID_COLORS.includes(args.color)) {
+        throw new Error(`Color must be one of: ${VALID_COLORS.join(', ')}`);
+    }
 }
+/**
+ * Validates that exactly one input method is specified and required combinations are met
+ * For generation: use --new or --seed (seed phrase)
+ * For restore: use --codes, --zodiacPwd, --encZodiacPwd, or --encZodiacPwdSplit (optionally with --load)
+ */
 function validateUseCase(args) {
-    // --restore requires either --seed or --load for input
-    if (args.restore && !args.seed && !args.load) {
-        throw new Error('--restore requires either --seed or --load to provide the numbers');
+    // For restore mode
+    if (args.restore) {
+        // --seed cannot be used with --restore
+        if (args.seed) {
+            throw new Error('--seed is only for seed phrases during generation. For restore, use --codes, --zodiacPwd, --encZodiacPwd, or --encZodiacPwdSplit');
+        }
+        if (args.new) {
+            throw new Error('--new cannot be used with --restore');
+        }
+        // Must have one of the restore input methods
+        if (!args.codes &&
+            !args.zodiacPwd &&
+            !args.encZodiacPwd &&
+            !args.encZodiacPwdSplit) {
+            throw new Error('--restore requires one of: --codes, --zodiacPwd, --encZodiacPwd, or --encZodiacPwdSplit (optionally with --load <file>)');
+        }
+    }
+    else {
+        // For generation mode, cannot use restore-specific flags
+        if (args.codes ||
+            args.zodiacPwd ||
+            args.encZodiacPwd ||
+            args.encZodiacPwdSplit) {
+            throw new Error('Restore input methods (--codes, --zodiacPwd, --encZodiacPwd, --encZodiacPwdSplit) require --restore flag');
+        }
     }
     // Check that we have at least one input method
-    const inputs = [args.new, args.seed, args.load].filter(Boolean);
+    const inputs = [
+        args.new,
+        args.seed,
+        args.codes,
+        args.zodiacPwd,
+        args.encZodiacPwd,
+        args.encZodiacPwdSplit
+    ].filter(Boolean);
     if (inputs.length === 0) {
-        throw new Error('Input required: exactly one of --new, --seed, or --load must be specified');
+        throw new Error('Input required: for generation use --new or --seed; for restore use --codes, --zodiacPwd, --encZodiacPwd, or --encZodiacPwdSplit');
     }
+    // Only one data input method allowed (--load is separate as it's just the file path)
     if (inputs.length > 1) {
-        throw new Error('Input conflict: only one of --new, --seed, or --load can be used');
+        throw new Error('Input conflict: only one data input method can be used at a time');
     }
 }
+/**
+ * Gets seed phrase based on input method (new, seed, or load)
+ * Returns empty array for restore mode (handled separately in main)
+ */
 function getSeedPhrase(args) {
+    // Handle restore mode upfront - will be processed separately in main
+    if (args.restore) {
+        return [];
+    }
     if (args.new) {
         console.log('🎲 Generating 12-word seed phrase...');
         return (0, core_1.generateSecureSeedPhrase)(12, 128);
     }
     if (args.seed) {
-        console.log('📥 Processing existing seed phrase...');
-        const words = args.seed
-            .split(' ')
-            .map((word) => word.trim())
-            .filter((word) => word.length > 0);
-        (0, core_1.validateBip39Words)(words);
-        return words;
-    }
-    // For restore mode, return empty array - will be handled in main function
-    if (args.restore) {
-        return [];
-    }
-    if (args.load) {
-        console.log(`📂 Loading from file: ${args.load}`);
-        try {
-            const fileContent = (0, core_1.loadArrayFromFile)(args.load);
-            // fileContent is always string[], join and split to handle both formats
-            const content = fileContent
-                .join(' ')
-                .split(/\s+/)
-                .filter((item) => item.length > 0);
-            if (args.restore) {
-                // For restore case - return empty array, will be handled in main function
-                console.log('📥 Loading numbers for restoration');
-                return [];
-            }
-            else {
-                // For seed phrase transformation
-                console.log('📥 Loading seed phrase for transformation');
+        if (args.load) {
+            // When --load is present, args.seed contains the file path
+            console.log(`📂 Loading seed phrase from file: ${args.seed}`);
+            try {
+                const fileContent = (0, core_1.loadArrayFromFile)(args.seed);
+                // fileContent is always string[], join and split to handle both formats
+                const content = fileContent
+                    .join(' ')
+                    .split(/\s+/)
+                    .filter((item) => item.length > 0);
+                console.log('📥 Processing seed phrase for transformation');
                 (0, core_1.validateBip39Words)(content);
                 return content;
             }
+            catch (error) {
+                throw new Error(`Failed to load file '${args.seed}': ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
-        catch (error) {
-            throw new Error(`Failed to load file '${args.load}': ${error instanceof Error ? error.message : String(error)}`);
+        else {
+            // Direct input as string
+            console.log('📥 Processing existing seed phrase...');
+            const words = args.seed
+                .split(' ')
+                .map((word) => word.trim())
+                .filter((word) => word.length > 0);
+            (0, core_1.validateBip39Words)(words);
+            return words;
         }
     }
     throw new Error('No valid use case specified');
 }
+/**
+ * Formats source information for error messages
+ */
+function formatSource(source) {
+    return source ? ` from ${source}` : '';
+}
+/**
+ * Gets appropriate label for input source
+ */
+function getInputLabel(source) {
+    return source ? 'File content' : 'Input';
+}
+/**
+ * Detects whether input appears to be a zodiac password or numbers
+ */
+function detectInputFormat(input) {
+    const hasSpaces = input.includes(' ');
+    const hasOnlyBase58Chars = BASE58_PATTERN.test(input);
+    return !hasSpaces &&
+        hasOnlyBase58Chars &&
+        input.length < MAX_ZODIAC_PASSWORD_LENGTH
+        ? 'zodiac-password'
+        : 'numbers';
+}
+/**
+ * Parses space-separated numbers from input string
+ */
+function parseNumbers(input) {
+    return input
+        .split(/\s+/)
+        .filter((item) => item.length > 0)
+        .map((code) => parseInt(code.trim()))
+        .filter((code) => !isNaN(code));
+}
+/**
+ * Decodes a zodiac password with explicit flag
+ */
+function decodeZodiacPassword(input, source) {
+    console.log(`📥 Decoding zodiac password${formatSource(source)}...`);
+    try {
+        const secretCodes = (0, core_1.decodePassword)(input);
+        console.log(`🔓 Zodiac password decoded to: ${secretCodes.join(' ')}`);
+        return secretCodes;
+    }
+    catch (error) {
+        throw new Error(`Failed to decode zodiac password${formatSource(source)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Attempts to auto-detect and decode zodiac password format
+ */
+function decodeZodiacPasswordWithAutoDetect(input, source) {
+    console.log(`🔍 Auto-detecting zodiac password format${formatSource(source)}...`);
+    try {
+        const secretCodes = (0, core_1.decodePassword)(input);
+        console.log(`🔓 Zodiac password decoded to: ${secretCodes.join(' ')}`);
+        return secretCodes;
+    }
+    catch (error) {
+        throw new Error(`${getInputLabel(source)} appears to be zodiac password but failed to decode: ${error instanceof Error ? error.message : String(error)}. Use --zodiac-password flag or ${source ? 'ensure file contains numbers' : 'provide numbers instead'}.`);
+    }
+}
 /**
  * Parses input string as either zodiac password or numbers based on flags and content
  */
 function parseSecretInput(input, useZodiacPassword, source) {
     if (useZodiacPassword) {
-        console.log(`📥 Decoding zodiac password${source ? ` from ${source}` : ''}...`);
-        try {
-            const secretCodes = (0, core_1.decodePassword)(input);
-            console.log(`🔓 Zodiac password decoded to: ${secretCodes.join(' ')}`);
-            return secretCodes;
-        }
-        catch (error) {
-            throw new Error(`Failed to decode zodiac password${source ? ` from ${source}` : ''}: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        return decodeZodiacPassword(input, source);
     }
-    else {
-        // Try to detect if input looks like a zodiac password (Base58) or numbers
-        const hasSpaces = input.includes(' ');
-        const hasOnlyBase58Chars = /^[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]+$/.test(input);
-        if (!hasSpaces && hasOnlyBase58Chars && input.length < 30) {
-            // Looks like a zodiac password, try to decode it
-            console.log(`🔍 Auto-detecting zodiac password format${source ? ` in ${source}` : ''}...`);
-            try {
-                const secretCodes = (0, core_1.decodePassword)(input);
-                console.log(`🔓 Zodiac password decoded to: ${secretCodes.join(' ')}`);
-                return secretCodes;
-            }
-            catch (error) {
-                throw new Error(`${source ? 'File content' : 'Input'} appears to be zodiac password but failed to decode: ${error instanceof Error ? error.message : String(error)}. Use --zodiac-password flag or ${source ? 'ensure file contains numbers' : 'provide numbers instead'}.`);
-            }
-        }
-        else {
-            // Parse as numbers
-            const codes = input
-                .split(/\s+/)
-                .filter((item) => item.length > 0)
-                .map((code) => parseInt(code.trim()))
-                .filter((code) => !isNaN(code));
-            return codes;
-        }
+    const format = detectInputFormat(input);
+    if (format === 'zodiac-password') {
+        return decodeZodiacPasswordWithAutoDetect(input, source);
     }
+    return parseNumbers(input);
 }
+/**
+ * Displays a formatted table showing the complete transformation process
+ * Shows original words through each transformation step to final shuffled codes
+ */
 function displayTable(originalWords, mappedNumbers, offsetNumbers, shuffledNumbers, base58Values, zodiacSign) {
     console.log('\n📊 SEED PHRASE TRANSFORMATION TABLE');
-    console.log('====================================');
-    console.log(`Original Words | Mapped Numbers | Birthday Offset | ${zodiacSign} Shuffled | Base58 directly mapped`);
-    console.log('---------------|----------------|-----------------|-----------------|---------------------');
+    console.log('================================================================');
+    console.log(`#    | Original Words   | Mapped | Offset | ${zodiacSign} Shuffled | Base58`);
+    console.log('-----|------------------|--------|--------|----------------|--------');
     for (let i = 0; i < originalWords.length; i++) {
-        const word = originalWords[i].padEnd(13);
-        const mapped = String(mappedNumbers[i]).padEnd(15);
-        const offset = String(offsetNumbers[i]).padEnd(16);
-        const shuffled = String(shuffledNumbers[i]).padEnd(15);
-        const base58 = base58Values[i].padEnd(2);
-        console.log(`${String(i + 1).padStart(2)}. ${word}  ${mapped}  ${offset}  ${shuffled}  ${base58}`);
-    }
-    console.log('---------------|----------------|-----------------|-----------------|---------------------');
-    console.log(`Final secret codes: ${shuffledNumbers.join(' ')}`);
-    console.log(`Original seed phrase: ${originalWords.join(' ')}`);
+        const num = String(i + 1).padStart(4);
+        const word = originalWords[i].padEnd(16);
+        const mapped = String(mappedNumbers[i]).padStart(6);
+        const offset = String(offsetNumbers[i]).padStart(6);
+        const shuffled = String(shuffledNumbers[i]).padStart(14);
+        const base58 = base58Values[i].padStart(6);
+        console.log(`${num} | ${word}  ${mapped}  ${offset}  ${shuffled}  ${base58}`);
+    }
+    console.log('-----|------------------|--------|--------|----------------|--------');
 }
+/**
+ * Main entry point for the BIP39 Zodiac CLI
+ * Handles argument parsing, validation, and orchestrates transformation or restoration
+ */
 async function main() {
     try {
         const parser = createParser();
@@ -425,33 +758,149 @@ async function main() {
         if (args.restore) {
             console.log('🔄 RESTORING ORIGINAL SEED PHRASE FROM SECRET CODES');
             console.log('==================================================');
+            const colorValue = COLOR_VALUES[args.color];
+            const isAdd = args.operation === 'add';
             let secretCodes;
-            if (args.seed) {
-                const input = args.seed.trim();
-                secretCodes = parseSecretInput(input, args['zodiac-password'] || false, '');
+            let inputString = '';
+            // Handle old import methods
+            if (args.codes) {
+                // --codes: Secret codes (numbers from string or file)
+                console.log('📥 Processing secret codes...');
+                if (args.load) {
+                    // When --load is present, args.codes contains the file path
+                    console.log(`📂 Loading from file: ${args.codes}`);
+                    const fileContent = (0, core_1.loadArrayFromFile)(args.codes);
+                    inputString = fileContent.join(' ').trim();
+                    secretCodes = parseNumbers(inputString);
+                }
+                else {
+                    // Direct input as string
+                    secretCodes = parseNumbers(args.codes);
+                }
+                (0, core_1.validateBip39Indices)(secretCodes);
             }
-            else if (args.load) {
-                const fileContent = (0, core_1.loadArrayFromFile)(args.load);
-                const content = fileContent.join(' ').trim();
-                secretCodes = parseSecretInput(content, args['zodiac-password'] || false, 'file');
+            else if (args.zodiacPwd) {
+                // --zodiacPwd: Plain unencrypted zodiac password (from string or file)
+                console.log('📥 Processing plain zodiac password...');
+                let passwordInput;
+                if (args.load) {
+                    // When --load is present, args.zodiacPwd contains the file path
+                    console.log(`📂 Loading from file: ${args.zodiacPwd}`);
+                    passwordInput = (0, core_1.loadArrayFromFile)(args.zodiacPwd).join('').trim();
+                }
+                else {
+                    // Direct input as string
+                    passwordInput = args.zodiacPwd;
+                }
+                secretCodes = (0, core_1.decodePassword)(passwordInput);
+            }
+            else if (args.encZodiacPwd) {
+                // --encZodiacPwd: Single encrypted password (from string or file)
+                console.log('📥 Processing encrypted zodiac password...');
+                let encryptedInput;
+                if (args.load) {
+                    // When --load is present, args.encZodiacPwd contains the file path
+                    console.log(`📂 Loading from file: ${args.encZodiacPwd}`);
+                    encryptedInput = (0, core_1.loadArrayFromFile)(args.encZodiacPwd).join('').trim();
+                }
+                else {
+                    // Direct input as string
+                    encryptedInput = args.encZodiacPwd;
+                }
+                // Use custom passphrase if provided, otherwise derive from memory keys
+                const memoryKeys = args.passphrase
+                    ? args.passphrase
+                    : deriveMemoryKeys(args.color, birthday, zodiacSign, args.operation);
+                if (args.passphrase) {
+                    console.log(`   Using custom passphrase`);
+                }
+                else {
+                    console.log(`   Memory keys: ${memoryKeys} (${args.operation} operation)`);
+                }
+                const decryptionResult = (0, core_1.decryptString)(encryptedInput, memoryKeys);
+                const decryptedPassword = decryptionResult.decrypted;
+                console.log(`✅ Decryption successful!`);
+                console.log(`🔓 Decrypted zodiac password: ${decryptedPassword}`);
+                secretCodes = (0, core_1.decodePassword)(decryptedPassword);
+            }
+            else if (args.encZodiacPwdSplit) {
+                // --encZodiacPwdSplit: Comma-separated split parts or from file (2 lines)
+                console.log('📥 Processing encrypted zodiac password (split parts)...');
+                let part1;
+                let part2;
+                if (args.load) {
+                    // When --load is present, args.encZodiacPwdSplit contains the file path
+                    console.log(`📂 Loading from file: ${args.encZodiacPwdSplit}`);
+                    const fileContent = (0, core_1.loadArrayFromFile)(args.encZodiacPwdSplit);
+                    if (fileContent.length === 2) {
+                        // Two lines: each line is a part
+                        part1 = fileContent[0].trim();
+                        part2 = fileContent[1].trim();
+                    }
+                    else if (fileContent.length === 1 && fileContent[0].includes(',')) {
+                        // One line with comma: split by comma
+                        const parts = fileContent[0].split(',').map((p) => p.trim());
+                        if (parts.length !== 2) {
+                            throw new Error(`Expected 2 comma-separated parts, got ${parts.length}`);
+                        }
+                        ;
+                        [part1, part2] = parts;
+                    }
+                    else {
+                        throw new Error(`Expected file to contain either 2 lines or 1 line with comma-separated parts, got ${fileContent.length} line(s)`);
+                    }
+                }
+                else {
+                    // Direct input as comma-separated string
+                    const parts = args.encZodiacPwdSplit.split(',').map((p) => p.trim());
+                    if (parts.length !== 2) {
+                        throw new Error(`Expected 2 comma-separated parts, got ${parts.length}`);
+                    }
+                    ;
+                    [part1, part2] = parts;
+                }
+                console.log(`🔀 Combining split parts...`);
+                console.log(`   Split point: ${birthday} + ${colorValue} = ${birthday + colorValue}`);
+                const combinedPassword = combineZodiacPassword(part1, part2, birthday, colorValue);
+                console.log(`✅ Parts combined successfully!`);
+                // Use custom passphrase if provided, otherwise derive from memory keys
+                const memoryKeys = args.passphrase
+                    ? args.passphrase
+                    : deriveMemoryKeys(args.color, birthday, zodiacSign, args.operation);
+                console.log(`\n🔓 Decrypting zodiac password...`);
+                if (args.passphrase) {
+                    console.log(`   Using custom passphrase`);
+                }
+                else {
+                    console.log(`   Memory keys: ${memoryKeys} (${args.operation} operation)`);
+                }
+                const decryptionResult = (0, core_1.decryptString)(combinedPassword, memoryKeys);
+                const decryptedPassword = decryptionResult.decrypted;
+                console.log(`✅ Decryption successful!`);
+                console.log(`🔓 Decrypted zodiac password: ${decryptedPassword}`);
+                secretCodes = (0, core_1.decodePassword)(decryptedPassword);
             }
             else {
-                throw new Error('No secret codes provided for restoration');
+                throw new Error('No restore input method specified. Use --codes, --zodiacPwd, --encZodiacPwd, or --encZodiacPwdSplit');
             }
-            (0, core_1.validateBip39Indices)(secretCodes);
             console.log(`📥 Input secret codes: ${secretCodes.join(' ')}`);
-            // Reverse the process: unshuffle → remove offset → get original words
+            // Reverse the process: unshuffle → remove color offset → remove birthday offset → get original words
             console.log(`🔄 Unshuffling with ${zodiacSign}...`);
             const unshuffleResult = (0, core_1.unshuffleByZodiac)(secretCodes, zodiacSign);
             if (!unshuffleResult.isValid) {
                 throw new Error('Failed to unshuffle - invalid codes or wrong zodiac sign');
             }
-            const offsetNumbers = unshuffleResult.restored;
-            console.log(`🔄 Removing birthday offset (${args.red ? '+' : '-'}${birthday})...`);
-            // Apply the REVERSE offset operation for restoration
-            const originalNumbers = args.red
-                ? (0, core_1.subtractOffset)(offsetNumbers, birthday)
-                : (0, core_1.addOffset)(offsetNumbers, birthday);
+            const afterUnshuffleNumbers = unshuffleResult.restored;
+            console.log(`🔄 Removing color offset ${args.color} (${isAdd ? '+' : '-'}${colorValue})...`);
+            // Apply the REVERSE color offset operation for restoration
+            const afterColorRemovalNumbers = isAdd
+                ? (0, core_1.subtractOffset)(afterUnshuffleNumbers, colorValue)
+                : (0, core_1.addOffset)(afterUnshuffleNumbers, colorValue);
+            console.log(`🔄 Removing birthday offset (${isAdd ? '+' : '-'}${birthday})...`);
+            // Apply the REVERSE birthday offset operation for restoration
+            const originalNumbers = isAdd
+                ? (0, core_1.subtractOffset)(afterColorRemovalNumbers, birthday)
+                : (0, core_1.addOffset)(afterColorRemovalNumbers, birthday);
             const originalWords = (0, core_1.indicesToWords)(originalNumbers);
             (0, core_1.validateBip39Words)(originalWords);
             console.log('\n✅ RESTORATION COMPLETE!');
@@ -481,58 +930,138 @@ async function main() {
             console.log('===================================');
             console.log(`📥 Input seed phrase: ${originalWords.join(' ')}`);
         }
-        // Process: words → numbers → offset → shuffle
-        console.log(`\n🔄 TRANSFORMATION PROCESS (${args.red ? 'RED (+)' : 'BLACK (-)'} ${birthday}, ${zodiacSign.toUpperCase()})`);
+        const colorValue = COLOR_VALUES[args.color];
+        const isAdd = args.operation === 'add';
+        // Process: words → numbers → birthday offset → color offset → shuffle
+        console.log(`\n🔄 TRANSFORMATION PROCESS (${isAdd ? 'ADD (+)' : 'SUBTRACT (-)'} ${birthday}, ${args.color.toUpperCase()}(${isAdd ? '+' : '-'}${colorValue}), ${zodiacSign.toUpperCase()})`);
         console.log('='.repeat(70));
         // Step 1: Convert words to numbers
         const mappedNumbers = (0, core_1.wordsToIndices)(originalWords);
         console.log(`📝 Step 1: Words → Numbers`);
         // Step 2: Apply birthday offset
-        const offsetNumbers = args.red
+        const birthdayOffsetNumbers = isAdd
             ? (0, core_1.addOffset)(mappedNumbers, birthday)
             : (0, core_1.subtractOffset)(mappedNumbers, birthday);
-        console.log(`📝 Step 2: ${args.red ? 'Add' : 'Subtract'} birthday offset (${birthday})`);
-        // Step 3: Apply zodiac shuffle
-        const shuffleResult = (0, core_1.shuffleByZodiac)(offsetNumbers, zodiacSign);
+        console.log(`📝 Step 2: ${isAdd ? 'Add' : 'Subtract'} birthday offset (${birthday})`);
+        // Step 3: Apply color offset
+        const colorOffsetNumbers = isAdd
+            ? (0, core_1.addOffset)(birthdayOffsetNumbers, colorValue)
+            : (0, core_1.subtractOffset)(birthdayOffsetNumbers, colorValue);
+        console.log(`📝 Step 3: ${isAdd ? 'Add' : 'Subtract'} color offset ${args.color} (${colorValue})`);
+        // Step 4: Apply zodiac shuffle
+        const shuffleResult = (0, core_1.shuffleByZodiac)(colorOffsetNumbers, zodiacSign);
         const shuffledNumbers = shuffleResult.shuffled;
-        console.log(`📝 Step 3: Shuffle with ${zodiacSign}`);
+        console.log(`📝 Step 4: Shuffle with ${zodiacSign}`);
         // Generate zodiac password and get individual Base58 values
-        let zodiacPassword;
+        let unencryptedZodiacPassword;
         let base58Values;
         try {
             const passwordResult = (0, core_1.encodePassword)(shuffledNumbers);
-            zodiacPassword = passwordResult.password;
+            unencryptedZodiacPassword = passwordResult.password;
             base58Values = passwordResult.individual;
         }
         catch (error) {
             throw new Error(`Failed to generate zodiac password: ${error instanceof Error ? error.message : String(error)}`);
         }
-        // Display the 5-column table with Base58 values
-        displayTable(originalWords, mappedNumbers, offsetNumbers, shuffledNumbers, base58Values, zodiacSign);
-        // Display zodiac password section
-        console.log('\n🔐 ZODIAC PASSWORD');
-        console.log('==================');
+        // Encrypt zodiac password (ALWAYS)
+        let zodiacPassword;
+        let splitResult;
+        let memoryKeys;
+        try {
+            // Use custom passphrase if provided, otherwise derive from memory keys
+            if (args.passphrase) {
+                memoryKeys = args.passphrase;
+                console.log(`\n🔒 Encrypting zodiac password...`);
+                console.log(`   Using custom passphrase`);
+            }
+            else {
+                memoryKeys = deriveMemoryKeys(args.color, birthday, zodiacSign, args.operation);
+                console.log(`\n🔒 Encrypting zodiac password...`);
+                console.log(`   Memory keys: ${memoryKeys} (${args.operation} operation)`);
+            }
+            const encryptionResult = (0, core_1.encryptString)(unencryptedZodiacPassword, memoryKeys);
+            zodiacPassword = encryptionResult.encrypted;
+            console.log(`✅ Encryption complete!`);
+            // Split the encrypted password using birthday + color
+            console.log(`\n🔀 Splitting encrypted password at position ${birthday} + ${colorValue} = ${birthday + colorValue}...`);
+            splitResult = splitZodiacPassword(zodiacPassword, birthday, colorValue);
+            console.log(`✅ Split complete!`);
+        }
+        catch (error) {
+            throw new Error(`Failed to encrypt zodiac password: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Handle export mode - output JSON and exit
+        if (args.export) {
+            console.log('\n📦 Generating export data...');
+            const bip39Passphrase = args.passphrase || '';
+            const exportData = generateExportData(originalWords, splitResult.part1, splitResult.part2, bip39Passphrase);
+            const jsonOutput = JSON.stringify(exportData, null, 2);
+            try {
+                (0, core_1.saveArrayToFile)([jsonOutput], args.export);
+                console.log(`✅ Export data saved to: ${args.export}`);
+            }
+            catch (error) {
+                console.error(`⚠️ Failed to save to file '${args.export}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        // Display the transformation table
+        displayTable(originalWords, mappedNumbers, colorOffsetNumbers, // Combined offset (birthday + color applied)
+        shuffledNumbers, base58Values, zodiacSign);
+        // Display inline format below table
+        console.log('\nOriginal Words:');
+        console.log(originalWords.join(' '));
+        console.log('\nMapped Numbers:');
+        console.log(mappedNumbers.join(' '));
+        console.log('\nOffset Applied:');
+        console.log(colorOffsetNumbers.join(' '));
+        console.log(`\n${zodiacSign} Shuffled:`);
+        console.log(shuffledNumbers.join(' '));
+        console.log('\nBase58:');
+        console.log(base58Values.join(' '));
+        // Display password information
+        console.log('\nZodiac Password:');
+        console.log(unencryptedZodiacPassword);
+        console.log('\nEncrypted Zodiac Password:');
         console.log(zodiacPassword);
-        console.log('\n✅ TRANSFORMATION COMPLETE!');
+        console.log('\nEncrypted Zodiac Password (Split Parts):');
+        console.log(`💡 Each part contains a portion of the encrypted password padded with random data`);
+        console.log(`   Both parts are required to reconstruct the original encrypted password`);
+        console.log(`Part 1: ${splitResult.part1}`);
+        console.log(`Part 2: ${splitResult.part2}`);
+        console.log(`Split point: ${birthday} + ${colorValue} = ${birthday + colorValue}`);
+        const passphraseFlag = args.passphrase
+            ? ` --passphrase "${args.passphrase}"`
+            : '';
         if (args['zodiac-password']) {
-            console.log(`🔐 Zodiac Password: ${zodiacPassword}`);
-            console.log(`📊 Secret codes: ${shuffledNumbers.join(' ')} (for reference)`);
-            console.log(`🔄 To restore, use: bip39zodiac --seed "${zodiacPassword}" --restore --zodiac-password --${args.red ? 'red' : 'black'} --birthday=${birthday} --zodiac=${args.zodiac}`);
+            console.log(`\n🔄 To restore, use: bip39zodiac --encZodiacPwdSplit "${splitResult.part1},${splitResult.part2}" --restore --operation=${args.operation} --birthday=${birthday} --zodiac=${args.zodiac} --color=${args.color}${passphraseFlag}`);
+            if (args.passphrase) {
+                console.log(`\n💡 Using custom passphrase for encryption`);
+            }
+            else {
+                console.log(`\n💡 Memory keys: ${memoryKeys} (${args.operation} operation - auto-derived from your parameters)`);
+            }
         }
         else {
-            console.log(`🔐 Use these secret codes: ${shuffledNumbers.join(' ')}`);
-            console.log(`🔑 Zodiac Password: ${zodiacPassword} (compact format)`);
-            console.log(`🔄 To restore, use: bip39zodiac --seed "${shuffledNumbers.join(' ')}" --restore --${args.red ? 'red' : 'black'} --birthday=${birthday} --zodiac=${args.zodiac}`);
-            console.log(`🔄 Or with zodiac password: bip39zodiac --seed "${zodiacPassword}" --restore --zodiac-password --${args.red ? 'red' : 'black'} --birthday=${birthday} --zodiac=${args.zodiac}`);
+            console.log(`\n🔄 To restore with codes: bip39zodiac --codes "${shuffledNumbers.join(' ')}" --restore --operation=${args.operation} --birthday=${birthday} --zodiac=${args.zodiac} --color=${args.color}`);
+            console.log(`\n🔄 To restore with zodiac password: bip39zodiac --zodiacPwd "${unencryptedZodiacPassword}" --restore --operation=${args.operation} --birthday=${birthday} --zodiac=${args.zodiac} --color=${args.color}`);
+            console.log(`\n🔄 To restore with encrypted split: bip39zodiac --encZodiacPwdSplit "${splitResult.part1},${splitResult.part2}" --restore --operation=${args.operation} --birthday=${birthday} --zodiac=${args.zodiac} --color=${args.color}${passphraseFlag}`);
         }
         // Save to file if --save option provided
         if (args.save) {
             try {
-                const contentToSave = args['zodiac-password']
-                    ? zodiacPassword
-                    : shuffledNumbers.join(' ');
-                (0, core_1.saveArrayToFile)([contentToSave], args.save);
-                console.log(`💾 Results saved to: ${args.save}`);
+                if (args['zodiac-password']) {
+                    // Save both split parts (part1 on first line, part2 on second line)
+                    (0, core_1.saveArrayToFile)([splitResult.part1, splitResult.part2], args.save);
+                    console.log(`💾 Split parts saved to: ${args.save}`);
+                    console.log(`   Part 1: Line 1`);
+                    console.log(`   Part 2: Line 2`);
+                }
+                else {
+                    // Save numeric codes
+                    (0, core_1.saveArrayToFile)([shuffledNumbers.join(' ')], args.save);
+                    console.log(`💾 Results saved to: ${args.save}`);
+                }
             }
             catch (error) {
                 console.error(`⚠️ Failed to save to file '${args.save}': ${error instanceof Error ? error.message : String(error)}`);