ff1-cli 1.0.0

package/dist/src/utilities/functions.js

@@ -0,0 +1,325 @@
+/**
+ * Function Calling Layer
+ * These are the actual implementations called by AI orchestrator via function calling
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+const chalk = require('chalk');
+const playlistBuilder = require('./playlist-builder');
+const ff1Device = require('./ff1-device');
+const domainResolver = require('./domain-resolver');
+/**
+ * Build DP1 v1.0.0 compliant playlist
+ *
+ * This is the actual implementation called by AI orchestrator's function calling.
+ * Uses core playlist-builder utilities.
+ *
+ * @param {Object} params - Build parameters
+ * @param {Array<Object>} params.items - Playlist items
+ * @param {string} [params.title] - Playlist title (auto-generated if not provided)
+ * @param {string} [params.slug] - Playlist slug (auto-generated if not provided)
+ * @returns {Promise<Object>} DP1 playlist
+ * @example
+ * const playlist = await buildDP1Playlist({ items, title: 'My Playlist' });
+ */
+async function buildDP1Playlist(params) {
+    const { items, title, slug } = params;
+    return await playlistBuilder.buildDP1Playlist({ items, title, slug });
+}
+/**
+ * Send playlist to FF1 device
+ *
+ * This is the actual implementation called by AI orchestrator's function calling.
+ *
+ * @param {Object} params - Send parameters
+ * @param {Object} params.playlist - DP1 playlist
+ * @param {string} [params.deviceName] - Device name (null for first device)
+ * @returns {Promise<Object>} Result
+ * @returns {boolean} returns.success - Whether send succeeded
+ * @returns {string} [returns.deviceHost] - Device host address
+ * @returns {string} [returns.deviceName] - Device name
+ * @returns {string} [returns.error] - Error message if failed
+ * @example
+ * const result = await sendPlaylistToDevice({ playlist, deviceName: 'MyDevice' });
+ */
+async function sendPlaylistToDevice(params) {
+    const { playlist, deviceName } = params;
+    const result = await ff1Device.sendPlaylistToDevice({
+        playlist,
+        deviceName,
+    });
+    if (result.success) {
+        console.log(chalk.green('\n✓ Sent to device'));
+        if (result.deviceName) {
+            console.log(chalk.gray(`  ${result.deviceName}`));
+        }
+    }
+    else {
+        console.error(chalk.red('\n✗ Could not send to device'));
+        if (result.error) {
+            console.error(chalk.red(`  ${result.error}`));
+        }
+    }
+    return result;
+}
+/**
+ * Resolve blockchain domain names to addresses
+ *
+ * This is the actual implementation called by AI orchestrator's function calling.
+ * Supports ENS (.eth) and TNS (.tez) domains with batch resolution.
+ *
+ * @param {Object} params - Resolution parameters
+ * @param {Array<string>} params.domains - Array of domain names to resolve
+ * @param {boolean} [params.displayResults] - Whether to display results (default: true)
+ * @returns {Promise<Object>} Resolution result
+ * @returns {boolean} returns.success - Whether at least one domain was resolved
+ * @returns {Object} returns.domainMap - Map of domain to resolved address
+ * @returns {Array<Object>} returns.resolutions - Detailed resolution results
+ * @returns {Array<string>} returns.errors - Array of error messages
+ * @example
+ * const result = await resolveDomains({ domains: ['vitalik.eth', 'alice.tez'] });
+ * console.log(result.domainMap); // { 'vitalik.eth': '0x...', 'alice.tez': 'tz...' }
+ */
+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}`));
+        return {
+            success: false,
+            domainMap: {},
+            resolutions: [],
+            errors: [error],
+        };
+    }
+    const result = await domainResolver.resolveDomainsBatch(domains);
+    if (displayResults) {
+        domainResolver.displayResolutionResults(result);
+    }
+    return result;
+}
+/**
+ * Verify a playlist against DP-1 specification
+ *
+ * This is the actual implementation called by AI orchestrator's function calling.
+ * Uses dp1-js library for standards-compliant validation. Must be called before
+ * sending a playlist to a device.
+ *
+ * @param {Object} params - Verification parameters
+ * @param {Object} params.playlist - Playlist object to verify
+ * @returns {Promise<Object>} Verification result
+ * @returns {boolean} returns.valid - Whether playlist is valid
+ * @returns {string} [returns.error] - Error message if invalid
+ * @returns {Array<Object>} [returns.details] - Detailed validation errors
+ * @example
+ * const result = await verifyPlaylist({ playlist });
+ * if (result.valid) {
+ *   console.log('Playlist is valid');
+ * } else {
+ *   console.error('Invalid:', result.error);
+ * }
+ */
+async function verifyPlaylist(params) {
+    const { playlist } = params;
+    if (!playlist) {
+        return {
+            valid: false,
+            error: 'No playlist provided for verification',
+        };
+    }
+    console.log(chalk.cyan('\nValidating playlist...'));
+    // Dynamic import to avoid circular dependency
+    const playlistVerifier = await Promise.resolve().then(() => __importStar(require('./playlist-verifier')));
+    const verify = playlistVerifier.verifyPlaylist ||
+        (playlistVerifier.default && playlistVerifier.default.verifyPlaylist) ||
+        playlistVerifier.default;
+    if (typeof verify !== 'function') {
+        return {
+            valid: false,
+            error: 'Playlist verifier is not available',
+        };
+    }
+    const result = verify(playlist);
+    if (result.valid) {
+        console.log(chalk.green('✓ Playlist looks good'));
+        if (playlist.title) {
+            console.log(chalk.gray(`  Title: ${playlist.title}`));
+        }
+        if (playlist.items) {
+            console.log(chalk.gray(`  Items: ${playlist.items.length}`));
+        }
+        console.log();
+    }
+    else {
+        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:'));
+            result.details.forEach((detail) => {
+                console.log(chalk.yellow(`    • ${detail.path}: ${detail.message}`));
+            });
+        }
+        console.log();
+    }
+    return result;
+}
+/**
+ * Verify and validate Ethereum and Tezos addresses
+ *
+ * This function is called by the intent parser to validate addresses entered by users.
+ * It provides detailed feedback on address validity and format issues.
+ *
+ * @param {Object} params - Verification parameters
+ * @param {Array<string>} params.addresses - Array of addresses to verify
+ * @returns {Promise<Object>} Verification result
+ * @returns {boolean} returns.valid - Whether all addresses are valid
+ * @returns {Array<Object>} returns.results - Detailed validation for each address
+ * @returns {Array<string>} returns.errors - List of validation errors
+ * @example
+ * const result = await verifyAddresses({
+ *   addresses: ['0x1234567890123456789012345678901234567890', 'tz1VSUr8wwNhLAzempoch5d6hLKEUNvD14']
+ * });
+ * if (!result.valid) {
+ *   result.errors.forEach(err => console.error(err));
+ * }
+ */
+async function verifyAddresses(params) {
+    const { addresses } = params;
+    if (!addresses || !Array.isArray(addresses) || addresses.length === 0) {
+        return {
+            valid: false,
+            results: [],
+            errors: ['No addresses provided for verification'],
+        };
+    }
+    // Dynamic import to avoid circular dependency
+    const addressValidator = await Promise.resolve().then(() => __importStar(require('./address-validator')));
+    const validateAddresses = addressValidator.validateAddresses ||
+        (addressValidator.default && addressValidator.default.validateAddresses) ||
+        addressValidator.default;
+    if (typeof validateAddresses !== 'function') {
+        return {
+            valid: false,
+            results: [],
+            errors: ['Address validator is not available'],
+        };
+    }
+    const result = validateAddresses(addresses);
+    // Display results
+    if (result.valid) {
+        console.log(chalk.green('\n✓ All addresses are valid'));
+        result.results.forEach((r) => {
+            const typeLabel = r.type === 'ethereum'
+                ? 'Ethereum'
+                : r.type === 'ens'
+                    ? 'ENS Domain'
+                    : r.type === 'tezos-domain'
+                        ? 'Tezos Domain'
+                        : r.type === 'contract'
+                            ? 'Tezos Contract'
+                            : 'Tezos User';
+            console.log(chalk.gray(`  • ${r.address} (${typeLabel})`));
+            if (r.normalized) {
+                console.log(chalk.gray(`    Checksummed: ${r.normalized}`));
+            }
+        });
+        console.log();
+    }
+    else {
+        console.error(chalk.red('\n✗ Address validation failed'));
+        result.errors.forEach((err) => {
+            console.error(chalk.red(`  • ${err}`));
+        });
+        console.log();
+    }
+    return result;
+}
+/**
+ * Get list of configured FF1 devices
+ *
+ * This function retrieves the list of all configured FF1 devices from config.
+ * Called by intent parser to resolve generic device references like "FF1", "my device".
+ *
+ * @returns {Promise<Object>} Device list result
+ * @returns {boolean} returns.success - Whether devices were retrieved
+ * @returns {Array<Object>} returns.devices - Array of device configurations
+ * @returns {string} returns.devices[].name - Device name
+ * @returns {string} returns.devices[].host - Device host URL
+ * @returns {string} [returns.devices[].topicID] - Optional topic ID
+ * @returns {string} [returns.error] - Error message if no devices configured
+ * @example
+ * const result = await getConfiguredDevices();
+ * if (result.success && result.devices.length > 0) {
+ *   const firstDevice = result.devices[0].name;
+ * }
+ */
+async function getConfiguredDevices() {
+    const configModule = await Promise.resolve().then(() => __importStar(require('../config')));
+    const getFF1DeviceConfig = configModule.getFF1DeviceConfig ||
+        (configModule.default && configModule.default.getFF1DeviceConfig) ||
+        configModule.default;
+    if (typeof getFF1DeviceConfig !== 'function') {
+        return {
+            success: false,
+            devices: [],
+            error: 'FF1 device configuration is not available',
+        };
+    }
+    const deviceConfig = getFF1DeviceConfig();
+    if (!deviceConfig.devices || deviceConfig.devices.length === 0) {
+        return {
+            success: false,
+            devices: [],
+            error: 'No FF1 devices configured',
+        };
+    }
+    // Return sanitized device list (without API keys)
+    const devices = deviceConfig.devices.map((d) => ({
+        name: d.name || d.host,
+        host: d.host,
+        topicID: d.topicID,
+    }));
+    return {
+        success: true,
+        devices,
+    };
+}
+module.exports = {
+    buildDP1Playlist,
+    sendPlaylistToDevice,
+    resolveDomains,
+    verifyPlaylist,
+    getConfiguredDevices,
+    verifyAddresses,
+};

package/dist/src/utilities/index.js

@@ -0,0 +1,372 @@
+/**
+ * Utilities - Actual function implementations
+ * Contains the real logic for querying NFTs and building playlists
+ */
+const chalk = require('chalk');
+const nftIndexer = require('./nft-indexer');
+const feedFetcher = require('./feed-fetcher');
+const playlistBuilder = require('./playlist-builder');
+const functions = require('./functions');
+const domainResolver = require('./domain-resolver');
+/**
+ * Initialize utilities with configuration
+ *
+ * The indexer now uses a hardcoded production endpoint, so no configuration is needed.
+ * This function is kept for backwards compatibility.
+ *
+ * @param {Object} _config - Unused config parameter
+ */
+function initializeUtilities(_config) {
+    nftIndexer.initializeIndexer();
+}
+/**
+ * Query tokens from an owner address
+ *
+ * Fetches all tokens owned by an address, with optional random selection.
+ * If no tokens found, instructs user to add address via Feral File mobile app.
+ * Supports pagination to fetch all tokens when quantity is "all".
+ *
+ * @param {string} ownerAddress - Owner wallet address
+ * @param {number|string} [quantity] - Number of random tokens to select, or "all" to fetch all tokens
+ * @param {number} duration - Duration per item in seconds
+ * @returns {Promise<Array>} Array of DP1 playlist items
+ */
+async function queryTokensByAddress(ownerAddress, quantity, duration = 10) {
+    try {
+        const shouldFetchAll = quantity === 'all' || quantity === undefined || quantity === null;
+        const batchSize = 100; // Fetch 100 tokens per page
+        let allTokens = [];
+        let offset = 0;
+        let hasMore = true;
+        // Fetch tokens with pagination if "all" is requested
+        if (shouldFetchAll) {
+            console.log(chalk.cyan(`   Fetching all tokens from ${ownerAddress}...`));
+            while (hasMore) {
+                const result = await nftIndexer.queryTokensByOwner(ownerAddress, batchSize, offset);
+                if (!result.success) {
+                    if (offset === 0) {
+                        // First page failed
+                        console.log(chalk.yellow(`   Could not fetch tokens for ${ownerAddress}`));
+                        console.log(chalk.cyan(`   → Add this address in the Feral File mobile app, then try again with the CLI.`));
+                        return [];
+                    }
+                    // Subsequent pages failed - stop pagination but keep what we have
+                    hasMore = false;
+                    break;
+                }
+                if (result.tokens.length === 0) {
+                    // No more tokens
+                    hasMore = false;
+                    break;
+                }
+                allTokens = allTokens.concat(result.tokens);
+                offset += batchSize;
+                console.log(chalk.gray(`   → 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;
+                }
+            }
+            if (allTokens.length === 0 && offset === 0) {
+                console.log(chalk.yellow(`   No tokens found for ${ownerAddress}`));
+                console.log(chalk.cyan(`   → Add this address in the Feral File mobile app, then try again with the CLI.`));
+                return [];
+            }
+        }
+        else {
+            // Fetch specific quantity with single request
+            const limit = Math.min(quantity, 100); // Cap at 100 per request
+            const result = await nftIndexer.queryTokensByOwner(ownerAddress, limit);
+            if (!result.success) {
+                console.log(chalk.yellow(`   Could not fetch tokens for ${ownerAddress}`));
+                console.log(chalk.cyan(`   → Add this address in the Feral File mobile app, then try again with the CLI.`));
+                return [];
+            }
+            if (result.tokens.length === 0) {
+                console.log(chalk.yellow(`   No tokens found for ${ownerAddress}`));
+                console.log(chalk.cyan(`   → Add this address in the Feral File mobile app, then try again with the CLI.`));
+                return [];
+            }
+            allTokens = result.tokens;
+        }
+        let selectedTokens = allTokens;
+        // Apply quantity limit with random selection (only if numeric quantity specified)
+        if (typeof quantity === 'number' && selectedTokens.length > quantity) {
+            selectedTokens = shuffleArray([...selectedTokens]).slice(0, quantity);
+        }
+        console.log(chalk.grey(`✓ Got ${selectedTokens.length} token(s)`));
+        // Convert tokens to DP1 items
+        const items = [];
+        let skippedCount = 0;
+        for (const token of selectedTokens) {
+            // Detect blockchain from contract address (support both camelCase and snake_case)
+            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) {
+                    items.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 items;
+    }
+    catch (error) {
+        console.error(chalk.red(`   Error: ${error.message}\n`));
+        throw error;
+    }
+}
+/**
+ * Query data for a single requirement (handles build_playlist, fetch_feed, and query_address)
+ *
+ * @param {Object} requirement - Requirement object
+ * @param {string} requirement.type - Requirement type (build_playlist, fetch_feed, or query_address)
+ * @param {string} [requirement.blockchain] - Blockchain network (for build_playlist)
+ * @param {string} [requirement.contractAddress] - Contract address (for build_playlist)
+ * @param {Array<string>} [requirement.tokenIds] - Token IDs (for build_playlist)
+ * @param {string} [requirement.ownerAddress] - Owner address (for query_address)
+ * @param {string} [requirement.playlistName] - Feed playlist name (for fetch_feed)
+ * @param {number} [requirement.quantity] - Number of items
+ * @param {number} duration - Duration per item in seconds
+ * @returns {Promise<Array>} Array of DP1 playlist items
+ */
+async function queryRequirement(requirement, duration = 10) {
+    const { type, blockchain, contractAddress, tokenIds, ownerAddress, playlistName, quantity } = requirement;
+    // Handle query_address type
+    if (type === 'query_address') {
+        // Check if ownerAddress is a domain name (.eth or .tez)
+        if (ownerAddress && (ownerAddress.endsWith('.eth') || ownerAddress.endsWith('.tez'))) {
+            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}`));
+                // Use resolved address instead of domain
+                return await queryTokensByAddress(resolution.address, quantity, duration);
+            }
+            else {
+                console.log(chalk.red(`  Could not resolve domain ${ownerAddress}: ${resolution.error || 'Unknown error'}`));
+                return [];
+            }
+        }
+        else {
+            return await queryTokensByAddress(ownerAddress, quantity, duration);
+        }
+    }
+    // Handle fetch_feed type
+    if (type === 'fetch_feed') {
+        console.log(chalk.cyan(`Getting items from "${playlistName}"...`));
+        const result = await feedFetcher.fetchFeedPlaylistDirect(playlistName, quantity, duration);
+        if (result.success && result.items) {
+            return result.items;
+        }
+        else {
+            console.log(chalk.yellow(`   Could not fetch playlist: ${result.error || 'No items found'}\n`));
+            return [];
+        }
+    }
+    // Handle build_playlist type (original NFT querying logic)
+    console.log(chalk.cyan(`Querying ${blockchain}${contractAddress ? ' (' + contractAddress.substring(0, 10) + '...)' : ''}...`));
+    let items = [];
+    try {
+        // Handle different blockchain types
+        if (blockchain.toLowerCase() === 'tezos') {
+            // Tezos NFTs
+            if (tokenIds && tokenIds.length > 0) {
+                const tokens = tokenIds.map((tokenId) => ({
+                    chain: 'tezos',
+                    contractAddress,
+                    tokenId,
+                }));
+                items = await nftIndexer.getNFTTokenInfoBatch(tokens, duration);
+            }
+            else {
+                console.log(chalk.yellow('   No token IDs specified'));
+            }
+        }
+        else if (blockchain.toLowerCase() === 'ethereum' || blockchain.toLowerCase() === 'eth') {
+            // Ethereum NFTs (including Art Blocks, Feral File, etc.)
+            if (contractAddress && tokenIds && tokenIds.length > 0) {
+                const tokens = tokenIds.map((tokenId) => ({
+                    chain: 'ethereum',
+                    contractAddress,
+                    tokenId,
+                }));
+                items = await nftIndexer.getNFTTokenInfoBatch(tokens, duration);
+            }
+            else {
+                console.log(chalk.yellow('   Contract address and token IDs required'));
+            }
+        }
+        else {
+            console.log(chalk.yellow(`   Unsupported blockchain: ${blockchain}`));
+        }
+        if (items.length > 0) {
+            console.log(chalk.green(`✓ Got ${items.length} item(s)`));
+        }
+        else {
+            console.log(chalk.yellow(`   No items found. Check token IDs, contract address, or try querying by owner address.`));
+        }
+        // Apply quantity limit
+        if (quantity && items.length > quantity) {
+            items = items.slice(0, quantity);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`   Error: ${error.message}\n`));
+        throw error;
+    }
+    return items;
+}
+/**
+ * Build DP1 playlist from items
+ *
+ * Uses the core playlist-builder utility to create a DP1 v1.0.0 compliant playlist.
+ *
+ * @param {Array<Object>} items - Array of DP1 playlist items
+ * @param {string} [title] - Playlist title
+ * @param {string} [slug] - Playlist slug
+ * @returns {Promise<Object>} DP1 playlist
+ * @example
+ * const playlist = await buildDP1Playlist(items, 'My Playlist', 'my-playlist');
+ */
+async function buildDP1Playlist(items, title, slug) {
+    return await playlistBuilder.buildDP1Playlist({ items, title, slug });
+}
+/**
+ * Send playlist to FF1 device
+ *
+ * @param {Object} playlist - DP1 playlist
+ * @param {string} [deviceName] - Device name
+ * @returns {Promise<Object>} Result
+ */
+async function sendToDevice(playlist, deviceName) {
+    const { sendPlaylistToDevice } = require('./functions');
+    return await sendPlaylistToDevice({ playlist, deviceName });
+}
+/**
+ * Shuffle array using Fisher-Yates algorithm
+ *
+ * @param {Array} array - Array to shuffle
+ * @returns {Array} Shuffled array
+ */
+function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+}
+/**
+ * Build playlist directly from requirements (deterministic, no AI)
+ *
+ * @param {Object} params - Playlist parameters
+ * @param {Array<Object>} params.requirements - Array of requirements
+ * @param {Object} params.playlistSettings - Playlist settings
+ * @param {Object} options - Build options
+ * @param {boolean} [options.verbose] - Verbose output
+ * @param {string} [options.outputPath] - Output file path
+ * @returns {Promise<Object>} Result with playlist
+ */
+async function buildPlaylistDirect(params, options = {}) {
+    const { requirements, playlistSettings } = params;
+    const { verbose = false, outputPath = 'playlist.json' } = options;
+    const allItems = [];
+    const duration = playlistSettings.durationPerItem || 10;
+    console.log(chalk.cyan('\nBuilding playlist from your requirements...\n'));
+    // Process each requirement
+    for (let i = 0; i < requirements.length; i++) {
+        const requirement = requirements[i];
+        const reqNum = i + 1;
+        console.log(chalk.cyan(`[${reqNum}/${requirements.length}] ${requirement.blockchain || 'Source'}`));
+        try {
+            const items = await queryRequirement(requirement, duration);
+            allItems.push(...items);
+        }
+        catch (error) {
+            console.error(chalk.red(`   ✗ Failed: ${error.message}`));
+            if (verbose) {
+                console.error(chalk.gray(error.stack));
+            }
+        }
+    }
+    if (allItems.length === 0) {
+        throw new Error('No items collected from any requirement');
+    }
+    // Apply ordering
+    let finalItems = allItems;
+    if (!playlistSettings.preserveOrder) {
+        console.log(chalk.cyan('Shuffling items...'));
+        finalItems = shuffleArray([...allItems]);
+    }
+    console.log(chalk.cyan(`Creating playlist with ${finalItems.length} items...`));
+    // Build DP1 playlist
+    const playlist = await buildDP1Playlist(finalItems, playlistSettings.title, playlistSettings.slug);
+    // Save playlist to file
+    const { savePlaylist } = require('../utils');
+    const savedPath = await savePlaylist(playlist, outputPath);
+    console.log(chalk.green(`✓ Playlist ready: ${savedPath}`));
+    // Send to device if requested
+    if (playlistSettings.deviceName !== undefined) {
+        console.log(chalk.cyan('\nSending to device...'));
+        await sendToDevice(playlist, playlistSettings.deviceName);
+    }
+    // Publish to feed server if requested
+    let publishResult = null;
+    if (playlistSettings.feedServer) {
+        console.log(chalk.cyan('\nPublishing to feed server...'));
+        try {
+            const { publishPlaylist } = require('./playlist-publisher');
+            publishResult = await publishPlaylist(savedPath, playlistSettings.feedServer.baseUrl, playlistSettings.feedServer.apiKey);
+            if (publishResult.success) {
+                console.log(chalk.green(`✓ Published to feed server`));
+                if (publishResult.playlistId) {
+                    console.log(chalk.gray(`   Playlist ID: ${publishResult.playlistId}`));
+                }
+                if (publishResult.feedServer) {
+                    console.log(chalk.gray(`   Server: ${publishResult.feedServer}`));
+                }
+            }
+            else {
+                console.error(chalk.red(`✗ Failed to publish: ${publishResult.error}`));
+                if (publishResult.message) {
+                    console.error(chalk.gray(`   ${publishResult.message}`));
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Failed to publish: ${error.message}`));
+            if (verbose) {
+                console.error(chalk.gray(error.stack));
+            }
+        }
+    }
+    return {
+        playlist,
+        published: publishResult?.success || false,
+        publishResult,
+    };
+}
+module.exports = {
+    initializeUtilities,
+    queryRequirement,
+    queryTokensByAddress,
+    buildDP1Playlist,
+    sendToDevice,
+    resolveDomains: functions.resolveDomains,
+    shuffleArray,
+    buildPlaylistDirect,
+    feedFetcher,
+    // Export core playlist builder utilities
+    playlistBuilder,
+};