ff1-cli 1.0.0 → 1.0.2

package/dist/src/main.js

@@ -116,17 +116,30 @@ function validateRequirements(requirements) {
             if (!req.blockchain) {
                 throw new Error(`Requirement ${index + 1}: blockchain is required for build_playlist`);
             }
-            if (!req.tokenIds || req.tokenIds.length === 0) {
-                throw new Error(`Requirement ${index + 1}: at least one token ID is required`);
+            if (!req.contractAddress) {
+                throw new Error(`Requirement ${index + 1}: contractAddress is required for build_playlist`);
+            }
+            // tokenIds is now optional - if not provided, query random tokens from contract
+            if (req.tokenIds && req.tokenIds.length > 0) {
+                // Specific token IDs provided
+                const quantity = typeof req.quantity === 'number'
+                    ? Math.min(req.quantity, 20)
+                    : Math.min(req.tokenIds.length, 20);
+                return {
+                    ...req,
+                    quantity,
+                    tokenIds: req.tokenIds,
+                };
+            }
+            else {
+                // No token IDs - query random tokens from contract
+                const quantity = typeof req.quantity === 'number' ? Math.min(req.quantity, 100) : 100;
+                return {
+                    ...req,
+                    quantity,
+                    tokenIds: undefined, // Explicitly set to undefined
+                };
             }
-            const quantity = typeof req.quantity === 'number'
-                ? Math.min(req.quantity, 20)
-                : Math.min(req.tokenIds.length, 20);
-            return {
-                ...req,
-                quantity,
-                tokenIds: req.tokenIds || [],
-            };
         }
         throw new Error(`Requirement ${index + 1}: invalid type "${req.type}"`);
     });
@@ -210,9 +223,9 @@ async function buildPlaylist(userRequest, options = {}) {
             }
             const sendResult = await utilities.sendToDevice(confirmation.playlist, confirmation.deviceName);
             if (sendResult.success) {
-                console.log(chalk_1.default.green('\n✅ Playlist sent successfully!'));
+                console.log(chalk_1.default.green('\nPlaylist sent'));
                 if (sendResult.deviceName) {
-                    console.log(chalk_1.default.gray(`   Device: ${sendResult.deviceName}`));
+                    console.log(chalk_1.default.dim(`  Device: ${sendResult.deviceName}`));
                 }
                 console.log();
                 return {
@@ -222,9 +235,9 @@ async function buildPlaylist(userRequest, options = {}) {
                 };
             }
             console.log();
-            console.error(chalk_1.default.red('❌ Failed to send playlist'));
+            console.error(chalk_1.default.red('Send failed'));
             if (sendResult.error) {
-                console.error(chalk_1.default.red(`   ${sendResult.error}`));
+                console.error(chalk_1.default.red(`  ${sendResult.error}`));
             }
             return {
                 success: false,
@@ -243,9 +256,9 @@ async function buildPlaylist(userRequest, options = {}) {
         while (intentParserResult.needsMoreInfo) {
             if (!interactive) {
                 // Non-interactive mode: cannot ask for clarification
-                console.error(chalk_1.default.red('\n❌ More information needed but running in non-interactive mode. Please provide a complete request.'));
+                console.error(chalk_1.default.red('\nNeed more information, but running in non-interactive mode. Provide a complete request.'));
                 if (intentParserResult.question) {
-                    console.error(chalk_1.default.yellow('\nAI asked: ') + intentParserResult.question);
+                    console.error(chalk_1.default.yellow('\nQuestion: ') + intentParserResult.question);
                 }
                 process.exit(1);
             }
@@ -256,7 +269,7 @@ async function buildPlaylist(userRequest, options = {}) {
             });
             // Display the AI's question before asking for input
             if (intentParserResult.question) {
-                console.log(chalk_1.default.cyan('\n🤖 ') + intentParserResult.question);
+                console.log(chalk_1.default.cyan('\n') + intentParserResult.question);
             }
             const userResponse = await new Promise((resolve) => {
                 rl.question(chalk_1.default.yellow('Your response: '), (answer) => {
@@ -265,7 +278,7 @@ async function buildPlaylist(userRequest, options = {}) {
                 });
             });
             if (!userResponse) {
-                console.error(chalk_1.default.red('\n❌ No response provided. Exiting.'));
+                console.error(chalk_1.default.red('\nNo response provided. Exiting.'));
                 process.exit(1);
             }
             console.log();
@@ -278,7 +291,7 @@ async function buildPlaylist(userRequest, options = {}) {
             });
         }
         if (!intentParserResult.approved) {
-            console.error(chalk_1.default.red('\n❌ Request not approved by intent parser'));
+            console.error(chalk_1.default.red('\nRequest not approved by intent parser'));
             return null;
         }
         const params = intentParserResult.params;
@@ -288,12 +301,12 @@ async function buildPlaylist(userRequest, options = {}) {
             const sendParams = params;
             const utilities = getUtilities();
             console.log();
-            console.log(chalk_1.default.cyan('Sending to device...'));
+            console.log(chalk_1.default.cyan('Sending to device'));
             const sendResult = await utilities.sendToDevice(sendParams.playlist, sendParams.deviceName);
             if (sendResult.success) {
-                console.log(chalk_1.default.green('\n✅ Playlist sent successfully!'));
+                console.log(chalk_1.default.green('\nPlaylist sent'));
                 if (sendResult.deviceName) {
-                    console.log(chalk_1.default.gray(`   Device: ${sendResult.deviceName}`));
+                    console.log(chalk_1.default.dim(`  Device: ${sendResult.deviceName}`));
                 }
                 console.log();
                 return {
@@ -305,9 +318,9 @@ async function buildPlaylist(userRequest, options = {}) {
             else {
                 // Send failed - return error without showing the playlist summary
                 console.log();
-                console.error(chalk_1.default.red('❌ Failed to send playlist'));
+                console.error(chalk_1.default.red('Send failed'));
                 if (sendResult.error) {
-                    console.error(chalk_1.default.red(`   ${sendResult.error}`));
+                    console.error(chalk_1.default.red(`  ${sendResult.error}`));
                 }
                 return {
                     success: false,
@@ -361,7 +374,7 @@ async function buildPlaylist(userRequest, options = {}) {
                 });
             });
             if (!userResponse) {
-                console.error(chalk_1.default.red('\n❌ No response provided. Canceling.'));
+                console.error(chalk_1.default.red('\nNo response provided. Canceling.'));
                 return null;
             }
             console.log();
@@ -379,14 +392,14 @@ async function buildPlaylist(userRequest, options = {}) {
         }
         // If no playlist was built, display the AI's message
         if (!result.playlist && result.message) {
-            console.log(chalk_1.default.yellow('\n⚠️  ' + result.message));
+            console.log(chalk_1.default.yellow('\n' + result.message));
         }
         return result;
     }
     catch (error) {
-        console.error(chalk_1.default.red('\n❌ Error:'), error.message);
+        console.error(chalk_1.default.red('\nError:'), error.message);
         if (verbose) {
-            console.error(chalk_1.default.gray(error.stack));
+            console.error(chalk_1.default.dim(error.stack));
         }
         throw error;
     }

package/dist/src/utilities/domain-resolver.js

@@ -277,14 +277,14 @@ function displayResolutionResults(result) {
     const successful = result.resolutions.filter((r) => r.resolved);
     if (successful.length > 0) {
         successful.forEach((resolution) => {
-            console.log(chalk_1.default.gray(`  ${resolution.domain} → ${resolution.address}`));
+            console.log(chalk_1.default.dim(`  ${resolution.domain} → ${resolution.address}`));
         });
     }
     // Display failures (but don't make them too prominent)
     const failed = result.resolutions.filter((r) => !r.resolved);
     if (failed.length > 0) {
         failed.forEach((resolution) => {
-            console.log(chalk_1.default.yellow(`  ✗ ${resolution.domain}: ${resolution.error || 'Could not resolve'}`));
+            console.log(chalk_1.default.yellow(`  ${resolution.domain}: ${resolution.error || 'Could not resolve'}`));
         });
     }
     console.log();

package/dist/src/utilities/feed-fetcher.js

@@ -28,7 +28,7 @@ async function fetchPlaylistsFromFeed(feedUrl, limit = 100) {
         const validLimit = Math.min(limit, 100);
         const response = await fetch(`${feedUrl}/playlists?limit=${validLimit}&sort=-created`);
         if (!response.ok) {
-            console.log(chalk.yellow(`   ⚠️  Feed ${feedUrl} returned ${response.status}`));
+            console.log(chalk.yellow(`  Feed ${feedUrl} returned ${response.status}`));
             return [];
         }
         const data = await response.json();
@@ -40,7 +40,7 @@ async function fetchPlaylistsFromFeed(feedUrl, limit = 100) {
         }));
     }
     catch (error) {
-        console.log(chalk.yellow(`   ⚠️  Failed to fetch from ${feedUrl}: ${error.message}`));
+        console.log(chalk.yellow(`  Failed to fetch from ${feedUrl}: ${error.message}`));
         return [];
     }
 }

package/dist/src/utilities/functions.js

@@ -80,13 +80,13 @@ async function sendPlaylistToDevice(params) {
         deviceName,
     });
     if (result.success) {
-        console.log(chalk.green('\n✓ Sent to device'));
+        console.log(chalk.green('\nSent to device'));
         if (result.deviceName) {
-            console.log(chalk.gray(`  ${result.deviceName}`));
+            console.log(chalk.dim(`  ${result.deviceName}`));
         }
     }
     else {
-        console.error(chalk.red('\n✗ Could not send to device'));
+        console.error(chalk.red('\nSend failed'));
         if (result.error) {
             console.error(chalk.red(`  ${result.error}`));
         }
@@ -115,7 +115,7 @@ async function resolveDomains(params) {
     const { domains, displayResults = true } = params;
     if (!domains || !Array.isArray(domains) || domains.length === 0) {
         const error = 'No domains provided for resolution';
-        console.error(chalk.red(`\n✗ ${error}`));
+        console.error(chalk.red(`\n${error}`));
         return {
             success: false,
             domainMap: {},
@@ -158,7 +158,7 @@ async function verifyPlaylist(params) {
             error: 'No playlist provided for verification',
         };
     }
-    console.log(chalk.cyan('\nValidating playlist...'));
+    console.log(chalk.cyan('\nValidate playlist'));
     // Dynamic import to avoid circular dependency
     const playlistVerifier = await Promise.resolve().then(() => __importStar(require('./playlist-verifier')));
     const verify = playlistVerifier.verifyPlaylist ||
@@ -172,17 +172,17 @@ async function verifyPlaylist(params) {
     }
     const result = verify(playlist);
     if (result.valid) {
-        console.log(chalk.green('✓ Playlist looks good'));
+        console.log(chalk.green('Playlist looks good'));
         if (playlist.title) {
-            console.log(chalk.gray(`  Title: ${playlist.title}`));
+            console.log(chalk.dim(`  Title: ${playlist.title}`));
         }
         if (playlist.items) {
-            console.log(chalk.gray(`  Items: ${playlist.items.length}`));
+            console.log(chalk.dim(`  Items: ${playlist.items.length}`));
         }
         console.log();
     }
     else {
-        console.error(chalk.red('✗ Playlist has issues'));
+        console.error(chalk.red('Playlist has issues'));
         console.error(chalk.red(`  ${result.error}`));
         if (result.details && result.details.length > 0) {
             console.log(chalk.yellow('\n  Missing or invalid fields:'));
@@ -249,15 +249,15 @@ async function verifyAddresses(params) {
                         : r.type === 'contract'
                             ? 'Tezos Contract'
                             : 'Tezos User';
-            console.log(chalk.gray(`  • ${r.address} (${typeLabel})`));
+            console.log(chalk.dim(`  • ${r.address} (${typeLabel})`));
             if (r.normalized) {
-                console.log(chalk.gray(`    Checksummed: ${r.normalized}`));
+                console.log(chalk.dim(`    Checksummed: ${r.normalized}`));
             }
         });
         console.log();
     }
     else {
-        console.error(chalk.red('\n✗ Address validation failed'));
+        console.error(chalk.red('\nAddress validation failed'));
         result.errors.forEach((err) => {
             console.error(chalk.red(`  • ${err}`));
         });

package/dist/src/utilities/index.js

@@ -34,7 +34,7 @@ function initializeUtilities(_config) {
 async function queryTokensByAddress(ownerAddress, quantity, duration = 10) {
     try {
         const shouldFetchAll = quantity === 'all' || quantity === undefined || quantity === null;
-        const batchSize = 100; // Fetch 100 tokens per page
+        const batchSize = 50; // Fetch 50 tokens per page
         let allTokens = [];
         let offset = 0;
         let hasMore = true;
@@ -61,7 +61,7 @@ async function queryTokensByAddress(ownerAddress, quantity, duration = 10) {
                 }
                 allTokens = allTokens.concat(result.tokens);
                 offset += batchSize;
-                console.log(chalk.gray(`   → Fetched ${allTokens.length} tokens so far...`));
+                console.log(chalk.dim(`   → Fetched ${allTokens.length} tokens so far...`));
                 // If we got fewer tokens than the batch size, we've reached the end
                 if (result.tokens.length < batchSize) {
                     hasMore = false;
@@ -94,7 +94,7 @@ async function queryTokensByAddress(ownerAddress, quantity, duration = 10) {
         if (typeof quantity === 'number' && selectedTokens.length > quantity) {
             selectedTokens = shuffleArray([...selectedTokens]).slice(0, quantity);
         }
-        console.log(chalk.grey(`✓ Got ${selectedTokens.length} token(s)`));
+        console.log(chalk.dim(`Got ${selectedTokens.length} token(s)`));
         // Convert tokens to DP1 items
         const items = [];
         let skippedCount = 0;
@@ -118,7 +118,7 @@ async function queryTokensByAddress(ownerAddress, quantity, duration = 10) {
             }
         }
         if (skippedCount > 0) {
-            console.log(chalk.yellow(`   ⚠ Skipped ${skippedCount} token(s) with invalid data (data URIs or URLs too long)`));
+            console.log(chalk.yellow(`   Skipped ${skippedCount} token(s) with invalid data (data URIs or URLs too long)`));
         }
         return items;
     }
@@ -150,7 +150,7 @@ async function queryRequirement(requirement, duration = 10) {
             console.log(chalk.cyan(`\nResolving domain ${ownerAddress}...`));
             const resolution = await domainResolver.resolveDomain(ownerAddress);
             if (resolution.resolved && resolution.address) {
-                console.log(chalk.gray(`  ${resolution.domain} → ${resolution.address}`));
+                console.log(chalk.dim(`  ${resolution.domain} → ${resolution.address}`));
                 // Use resolved address instead of domain
                 return await queryTokensByAddress(resolution.address, quantity, duration);
             }
@@ -179,7 +179,58 @@ async function queryRequirement(requirement, duration = 10) {
     console.log(chalk.cyan(`Querying ${blockchain}${contractAddress ? ' (' + contractAddress.substring(0, 10) + '...)' : ''}...`));
     let items = [];
     try {
-        // Handle different blockchain types
+        // Check if we're querying by contract (no specific token IDs) or by specific token IDs
+        const isContractQuery = contractAddress && (!tokenIds || tokenIds.length === 0);
+        if (isContractQuery) {
+            // Query random tokens from the contract
+            console.log(chalk.cyan(`   Fetching ${quantity || 100} random token(s) from contract ${contractAddress.substring(0, 10)}...`));
+            const limit = Math.min(quantity || 100, 100);
+            const result = await nftIndexer.queryTokensByContract(contractAddress, limit);
+            if (!result.success) {
+                console.log(chalk.yellow(`   Could not fetch tokens from contract`));
+                console.log(chalk.cyan(`   → Trying as owner address instead...`));
+                return await queryTokensByAddress(contractAddress, quantity, duration);
+            }
+            if (result.tokens.length === 0) {
+                console.log(chalk.yellow(`   No tokens found in contract ${contractAddress}`));
+                console.log(chalk.cyan(`   → Trying as owner address instead...`));
+                return await queryTokensByAddress(contractAddress, quantity, duration);
+            }
+            // Convert tokens to DP1 items (similar to queryTokensByAddress logic)
+            let allTokens = result.tokens;
+            // Apply quantity limit with random selection if needed
+            if (quantity && allTokens.length > quantity) {
+                allTokens = shuffleArray([...allTokens]).slice(0, quantity);
+            }
+            console.log(chalk.dim(`   Got ${allTokens.length} token(s)`));
+            // Convert tokens to DP1 items
+            const dp1Items = [];
+            let skippedCount = 0;
+            for (const token of allTokens) {
+                // Detect blockchain from contract address
+                let chain = 'ethereum';
+                const contractAddr = token.contract_address || token.contractAddress || '';
+                if (contractAddr.startsWith('KT')) {
+                    chain = 'tezos';
+                }
+                // Map indexer token data to standard format
+                const tokenData = nftIndexer.mapIndexerDataToStandardFormat(token, chain);
+                if (tokenData.success) {
+                    const dp1Result = nftIndexer.convertToDP1Item(tokenData, duration);
+                    if (dp1Result.success && dp1Result.item) {
+                        dp1Items.push(dp1Result.item);
+                    }
+                    else if (!dp1Result.success) {
+                        skippedCount++;
+                    }
+                }
+            }
+            if (skippedCount > 0) {
+                console.log(chalk.yellow(`   Skipped ${skippedCount} token(s) with invalid data (data URIs or URLs too long)`));
+            }
+            return dp1Items;
+        }
+        // Handle specific token IDs (original logic)
         if (blockchain.toLowerCase() === 'tezos') {
             // Tezos NFTs
             if (tokenIds && tokenIds.length > 0) {
@@ -294,9 +345,9 @@ async function buildPlaylistDirect(params, options = {}) {
             allItems.push(...items);
         }
         catch (error) {
-            console.error(chalk.red(`   ✗ Failed: ${error.message}`));
+            console.error(chalk.red(`  Failed: ${error.message}`));
             if (verbose) {
-                console.error(chalk.gray(error.stack));
+                console.error(chalk.dim(error.stack));
             }
         }
     }
@@ -331,23 +382,23 @@ async function buildPlaylistDirect(params, options = {}) {
             if (publishResult.success) {
                 console.log(chalk.green(`✓ Published to feed server`));
                 if (publishResult.playlistId) {
-                    console.log(chalk.gray(`   Playlist ID: ${publishResult.playlistId}`));
+                    console.log(chalk.dim(`   Playlist ID: ${publishResult.playlistId}`));
                 }
                 if (publishResult.feedServer) {
-                    console.log(chalk.gray(`   Server: ${publishResult.feedServer}`));
+                    console.log(chalk.dim(`   Server: ${publishResult.feedServer}`));
                 }
             }
             else {
-                console.error(chalk.red(`✗ Failed to publish: ${publishResult.error}`));
+                console.error(chalk.red(`Publish failed: ${publishResult.error}`));
                 if (publishResult.message) {
-                    console.error(chalk.gray(`   ${publishResult.message}`));
+                    console.error(chalk.dim(`   ${publishResult.message}`));
                 }
             }
         }
         catch (error) {
-            console.error(chalk.red(`✗ Failed to publish: ${error.message}`));
+            console.error(chalk.red(`Publish failed: ${error.message}`));
             if (verbose) {
-                console.error(chalk.gray(error.stack));
+                console.error(chalk.dim(error.stack));
             }
         }
     }

package/dist/src/utilities/nft-indexer.js

@@ -98,14 +98,17 @@ function buildTokenCID(chain, contractAddress, tokenId) {
  * const tokens = await queryTokens({ token_cids: ['eip155:1:erc721:0xabc:123'], owners: ['0x1234...'] });
  */
 async function queryTokens(params = {}) {
-    const { token_cids = [], owners = [], limit = 50, offset = 0 } = params;
+    const { token_cids = [], owners = [], contract_addresses = [], limit = 50, offset = 0 } = params;
     // Build GraphQL query without variables - inline parameters
     // (API expects inline parameters, not variables)
     const ownerFilter = owners.length > 0 ? `owners: ${JSON.stringify(owners)},` : '';
     const tokenCidsFilter = token_cids.length > 0 ? `token_cids: ${JSON.stringify(token_cids)},` : '';
+    const contractFilter = contract_addresses.length > 0
+        ? `contract_addresses: ${JSON.stringify(contract_addresses)},`
+        : '';
     const query = `
       query {
-        tokens(${ownerFilter} ${tokenCidsFilter} expands: ["enrichment_source", "metadata_media_asset", "enrichment_source_media_asset"], limit: ${limit}, offset: ${offset}) {
+        tokens(${ownerFilter} ${tokenCidsFilter} ${contractFilter} expands: ["enrichment_source", "metadata_media_asset", "enrichment_source_media_asset"], limit: ${limit}, offset: ${offset}) {
         items {
           token_cid
           chain
@@ -958,26 +961,45 @@ async function searchNFTs(params) {
  */
 async function queryTokensByOwner(ownerAddress, limit = 100, offset = 0) {
     try {
-        logger.info(`[NFT Indexer] Querying tokens for owner: ${ownerAddress} (limit: ${limit}, offset: ${offset})`);
+        logger.info(`[NFT Indexer] Querying tokens by owner: ${ownerAddress}`);
         const tokens = await queryTokens({
             owners: [ownerAddress],
             limit,
             offset,
         });
-        logger.info(`[NFT Indexer] Found ${tokens.length} token(s) for owner ${ownerAddress}`);
         return {
             success: true,
             tokens,
-            count: tokens.length,
         };
     }
     catch (error) {
-        logger.error('[NFT Indexer] Failed to query tokens by owner:', error.message);
+        logger.error(`[NFT Indexer] Failed to query tokens by owner: ${error.message}`);
         return {
             success: false,
+            tokens: [],
             error: error.message,
+        };
+    }
+}
+async function queryTokensByContract(contractAddress, limit = 100, offset = 0) {
+    try {
+        logger.info(`[NFT Indexer] Querying tokens by contract: ${contractAddress}`);
+        const tokens = await queryTokens({
+            contract_addresses: [contractAddress],
+            limit,
+            offset,
+        });
+        return {
+            success: true,
+            tokens,
+        };
+    }
+    catch (error) {
+        logger.error(`[NFT Indexer] Failed to query tokens by contract: ${error.message}`);
+        return {
+            success: false,
             tokens: [],
-            count: 0,
+            error: error.message,
         };
     }
 }
@@ -998,6 +1020,7 @@ module.exports = {
     convertToDP1Item,
     // Address-based functions
     queryTokensByOwner,
+    queryTokensByContract,
     // Unified GraphQL query
     queryTokens,
     // Workflow and polling functions

package/dist/src/utilities/playlist-send.js

@@ -65,7 +65,7 @@ async function getAvailableDevices() {
     }
     catch (error) {
         if (process.env.DEBUG) {
-            console.log(chalk_1.default.gray(`[DEBUG] Error loading devices: ${error.message}`));
+            console.log(chalk_1.default.dim(`[DEBUG] Error loading devices: ${error.message}`));
         }
         // Silently fail if config can't be loaded
     }
@@ -87,23 +87,23 @@ async function confirmPlaylistForSending(filePath, deviceName) {
     // Convert string "null" to undefined (in case model passes it literally)
     const actualDeviceName = deviceName === 'null' || deviceName === '' ? undefined : deviceName;
     if (process.env.DEBUG) {
-        console.error(chalk_1.default.gray(`[DEBUG] confirmPlaylistForSending called with: filePath="${filePath}", deviceName="${deviceName}" -> "${actualDeviceName}"`));
+        console.error(chalk_1.default.dim(`[DEBUG] confirmPlaylistForSending called with: filePath="${filePath}", deviceName="${deviceName}" -> "${actualDeviceName}"`));
     }
     try {
         // Check if file exists
-        console.log(chalk_1.default.cyan(`Checking playlist file: ${resolvedPath}...`));
+        console.log(chalk_1.default.cyan(`Playlist file: ${resolvedPath}`));
         let _fileExists = false;
         let playlist;
         try {
             const content = await fs_1.promises.readFile(resolvedPath, 'utf-8');
             playlist = JSON.parse(content);
             _fileExists = true;
-            console.log(chalk_1.default.green('✓ File found'));
+            console.log(chalk_1.default.green('File loaded'));
         }
         catch (error) {
             const errorMsg = error.message;
             if (errorMsg.includes('ENOENT') || errorMsg.includes('no such file')) {
-                console.log(chalk_1.default.red(`✗ File not found: ${resolvedPath}`));
+                console.log(chalk_1.default.red(`File not found: ${resolvedPath}`));
                 return {
                     success: false,
                     filePath: resolvedPath,
@@ -125,12 +125,12 @@ async function confirmPlaylistForSending(filePath, deviceName) {
             };
         }
         // Validate playlist structure
-        console.log(chalk_1.default.cyan('Validating playlist...'));
+        console.log(chalk_1.default.cyan('Validation'));
         // Dynamic import to avoid circular dependency
         const { verifyPlaylist } = await Promise.resolve().then(() => __importStar(require('./playlist-verifier')));
         const verifyResult = verifyPlaylist(playlist);
         if (!verifyResult.valid) {
-            console.log(chalk_1.default.red('✗ Playlist validation failed'));
+            console.log(chalk_1.default.red('Playlist validation failed'));
             const detailLines = verifyResult.details?.map((d) => `  • ${d.path}: ${d.message}`).join('\n') ||
                 verifyResult.error;
             const detailPaths = verifyResult.details?.map((d) => d.path) || [];
@@ -153,7 +153,7 @@ async function confirmPlaylistForSending(filePath, deviceName) {
                 message: `This playlist doesn't match DP-1 specification.\n\nErrors:\n${detailLines}${hintText}`,
             };
         }
-        console.log(chalk_1.default.green('✓ Playlist is valid'));
+        console.log(chalk_1.default.green('Valid DP-1 playlist'));
         // Display confirmation details
         const itemCount = playlist.items?.length || 0;
         const title = playlist.title || 'Untitled';
@@ -165,10 +165,10 @@ async function confirmPlaylistForSending(filePath, deviceName) {
             // Get available devices
             availableDevices = await getAvailableDevices();
             if (process.env.DEBUG) {
-                console.error(chalk_1.default.gray(`[DEBUG] selectedDevice is null/undefined`));
-                console.error(chalk_1.default.gray(`[DEBUG] Available devices found: ${availableDevices.length}`));
+                console.error(chalk_1.default.dim(`[DEBUG] selectedDevice is null/undefined`));
+                console.error(chalk_1.default.dim(`[DEBUG] Available devices found: ${availableDevices.length}`));
                 availableDevices.forEach((d) => {
-                    console.error(chalk_1.default.gray(`[DEBUG] Device: ${d.name} (${d.host})`));
+                    console.error(chalk_1.default.dim(`[DEBUG] Device: ${d.name} (${d.host})`));
                 });
             }
             if (availableDevices.length === 0) {
@@ -185,7 +185,7 @@ async function confirmPlaylistForSending(filePath, deviceName) {
             else if (availableDevices.length === 1) {
                 // Auto-select single device
                 selectedDevice = availableDevices[0].name || availableDevices[0].host;
-                console.log(chalk_1.default.cyan(`Auto-selecting device: ${selectedDevice}`));
+                console.log(chalk_1.default.cyan(`Device: ${selectedDevice} (auto)`));
             }
             else {
                 // Multiple devices - need user to choose
@@ -193,14 +193,14 @@ async function confirmPlaylistForSending(filePath, deviceName) {
             }
         }
         console.log();
-        console.log(chalk_1.default.bold('Playlist Summary:'));
-        console.log(chalk_1.default.gray(`  Title: ${title}`));
-        console.log(chalk_1.default.gray(`  Items: ${itemCount}`));
+        console.log(chalk_1.default.bold('Send Summary'));
+        console.log(chalk_1.default.dim(`  Title: ${title}`));
+        console.log(chalk_1.default.dim(`  Items: ${itemCount}`));
         if (selectedDevice) {
-            console.log(chalk_1.default.gray(`  Device: ${selectedDevice}`));
+            console.log(chalk_1.default.dim(`  Device: ${selectedDevice}`));
         }
         else if (availableDevices.length > 1) {
-            console.log(chalk_1.default.gray(`  Device: (to be selected)`));
+            console.log(chalk_1.default.dim('  Device: select one'));
         }
         console.log();
         // If multiple devices, return needsDeviceSelection flag
@@ -229,7 +229,7 @@ async function confirmPlaylistForSending(filePath, deviceName) {
     }
     catch (error) {
         const errorMsg = error.message;
-        console.log(chalk_1.default.red(`✗ Error: ${errorMsg}`));
+        console.log(chalk_1.default.red(`Error: ${errorMsg}`));
         return {
             success: false,
             filePath: resolvedPath,

package/dist/src/utilities/playlist-verifier.js

@@ -125,30 +125,30 @@ async function verifyPlaylistFile(playlistPath) {
  */
 function printVerificationResult(result, filename) {
     if (result.valid) {
-        console.log(chalk_1.default.green('\n✅ Playlist is valid!'));
+        console.log(chalk_1.default.green('\nPlaylist is valid'));
         if (filename) {
-            console.log(chalk_1.default.gray(`   File: ${filename}`));
+            console.log(chalk_1.default.dim(`  File: ${filename}`));
         }
         if (result.playlist) {
-            console.log(chalk_1.default.gray(`   Title: ${result.playlist.title}`));
-            console.log(chalk_1.default.gray(`   Items: ${result.playlist.items?.length || 0}`));
-            console.log(chalk_1.default.gray(`   DP Version: ${result.playlist.dpVersion}`));
+            console.log(chalk_1.default.dim(`  Title: ${result.playlist.title}`));
+            console.log(chalk_1.default.dim(`  Items: ${result.playlist.items?.length || 0}`));
+            console.log(chalk_1.default.dim(`  DP Version: ${result.playlist.dpVersion}`));
             if (result.playlist.signature && typeof result.playlist.signature === 'string') {
-                console.log(chalk_1.default.gray(`   Signature: ${result.playlist.signature.substring(0, 30)}...`));
+                console.log(chalk_1.default.dim(`  Signature: ${result.playlist.signature.substring(0, 30)}...`));
             }
         }
         console.log();
     }
     else {
-        console.log(chalk_1.default.red('\n❌ Playlist validation failed!'));
+        console.log(chalk_1.default.red('\nPlaylist validation failed'));
         if (filename) {
-            console.log(chalk_1.default.gray(`   File: ${filename}`));
+            console.log(chalk_1.default.dim(`  File: ${filename}`));
         }
-        console.log(chalk_1.default.red(`   Error: ${result.error}`));
+        console.log(chalk_1.default.red(`  Error: ${result.error}`));
         if (result.details && result.details.length > 0) {
-            console.log(chalk_1.default.yellow('\n   Validation errors:'));
+            console.log(chalk_1.default.yellow('\n  Validation errors:'));
             result.details.forEach((detail) => {
-                console.log(chalk_1.default.yellow(`     • ${detail.path}: ${detail.message}`));
+                console.log(chalk_1.default.yellow(`    • ${detail.path}: ${detail.message}`));
             });
         }
         console.log();