ff1-cli 1.0.0 → 1.0.1

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();

package/docs/EXAMPLES.md

@@ -23,7 +23,7 @@ npm run dev -- chat "Get 3 items from Social Codes and 2 from 0xdef" -v
 
 # Switch model
 npm run dev -- chat "your request" --model grok
-npm run dev -- chat "your request" --model chatgpt
+npm run dev -- chat "your request" --model gpt
 npm run dev -- chat "your request" --model gemini
 ```
 
@@ -44,7 +44,7 @@ cat examples/params-example.json | npm run dev -- build -o playlist.json
 npm run dev -- chat "Build a playlist of my Tezos works from address tz1... plus 3 from Social Codes" -v -o playlist.json
 
 # Switch model if desired
-npm run dev -- chat "Build playlist from Ethereum address 0x... and 2 from Social Codes" --model chatgpt -v
+npm run dev -- chat "Build playlist from Ethereum address 0x... and 2 from Social Codes" --model gpt -v
 ```
 
 ### One‑shot complex prompt
@@ -92,18 +92,21 @@ npm run dev -- chat "Get 5 from Social Codes, shuffle, display on 'Living Room',
 ### How It Works
 
 **Mode 1: Build and Publish** (when sources are mentioned)
+
 1. Intent parser detects "publish" keywords with sources/requirements
 2. Calls `get_feed_servers` to retrieve configured servers
 3. If 1 server → uses it automatically; if 2+ servers → asks user to pick
 4. Builds playlist → verifies → publishes automatically
 
 **Mode 2: Publish Existing File** (e.g., "publish playlist")
+
 1. Intent parser detects "publish playlist" or similar phrases
 2. Calls `get_feed_servers` to retrieve configured servers
 3. If 1 server → uses it automatically; if 2+ servers → asks user to pick
 4. Publishes the playlist from `./playlist.json` (or specified path)
 
 Output shows:
+
 - Playlist build progress (Mode 1 only)
 - Device sending (if requested): `✓ Sent to device: Living Room`
 - Publishing status: `✓ Published to feed server`
@@ -187,18 +190,21 @@ Select server (0-based index): 0
 ### Error Handling
 
 **Validation failed:**
+
 ```
 ❌ Failed to publish playlist
    Playlist validation failed: dpVersion: Required; id: Required
 ```
 
 **File not found:**
+
 ```
 ❌ Failed to publish playlist
    Playlist file not found: /path/to/playlist.json
 ```
 
 **API error:**
+
 ```
 ❌ Failed to publish playlist
    Failed to publish: {"error":"unauthorized","message":"Invalid API key"}
@@ -233,7 +239,6 @@ npm run dev -- config show
 npm run dev -- config init
 ```
 
-
 ### Natural‑language one‑shot examples (proven)
 
 - **ETH contract + token IDs (shuffle/mix, generic device)**
@@ -328,4 +333,4 @@ npm run dev -- config init
     ```bash
     npm run dev -- chat "Compose a playlist from reas.eth (3 items); send to device" -o playlist-generic-device.json -v
     npm run dev -- chat "Compose a playlist from reas.eth (3 items); send to 'Living Room'" -o playlist-named-device.json -v
-    ```
+    ```

package/docs/README.md

@@ -40,7 +40,7 @@ See the full configuration reference here: `./CONFIGURATION.md`.
       "model": "grok-beta",
       "supportsFunctionCalling": true
     },
-    "chatgpt": {
+    "gpt": {
       "apiKey": "sk-your-openai-key-here",
       "baseURL": "https://api.openai.com/v1",
       "model": "gpt-4o",
@@ -163,7 +163,7 @@ How it works (at a glance):
 - If `deviceName` is present, the CLI will send the validated playlist to that FF1 device.
 - If `feedServer` is present (via "publish to my feed"), the CLI will publish the playlist to the selected feed server.
 
-Use `--model grok|chatgpt|gemini` to switch models, or set `defaultModel` in `config.json`.
+Use `--model grok|gpt|gemini` to switch models, or set `defaultModel` in `config.json`.
 
 ### Natural language publishing
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "ff1-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CLI to fetch NFT information and build DP1 playlists using Grok API",
   "main": "dist/index.js",
   "bin": {
-    "ff1": "./dist/index.js"
+    "ff1": "dist/index.js"
   },
   "files": [
     "dist",