gopeak 2.0.0

package/build/providers/ambientcg.js

@@ -0,0 +1,174 @@
+import { existsSync, mkdirSync, createWriteStream, appendFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import * as https from 'https';
+const AMBIENTCG_CONFIG = {
+    name: 'ambientcg',
+    displayName: 'AmbientCG',
+    baseUrl: 'https://ambientcg.com',
+    apiUrl: 'https://ambientcg.com/api/v2/full_json',
+    userAgent: 'GodotMCP/1.0',
+    priority: 2,
+    supportedTypes: ['textures', 'models', 'hdris'],
+    requiresAuth: false,
+    license: 'CC0',
+};
+function mapDataTypeToAssetType(dataType) {
+    switch (dataType.toLowerCase()) {
+        case 'material':
+        case 'decal':
+        case 'terrain':
+            return 'textures';
+        case '3dmodel':
+            return 'models';
+        case 'hdri':
+            return 'hdris';
+        default:
+            return 'textures';
+    }
+}
+function httpGet(url, userAgent) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': userAgent } }, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                const redirectUrl = res.headers.location;
+                if (redirectUrl) {
+                    httpGet(redirectUrl, userAgent).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => resolve(data));
+        }).on('error', reject);
+    });
+}
+function downloadFile(url, destPath, userAgent) {
+    return new Promise((resolve, reject) => {
+        const file = createWriteStream(destPath);
+        const request = (currentUrl) => {
+            https.get(currentUrl, { headers: { 'User-Agent': userAgent } }, (response) => {
+                if (response.statusCode === 301 || response.statusCode === 302) {
+                    const redirectUrl = response.headers.location;
+                    if (redirectUrl) {
+                        request(redirectUrl);
+                        return;
+                    }
+                }
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            }).on('error', (err) => {
+                file.close();
+                reject(err);
+            });
+        };
+        request(url);
+    });
+}
+export class AmbientCGProvider {
+    config = AMBIENTCG_CONFIG;
+    supportsType(type) {
+        return this.config.supportedTypes.includes(type);
+    }
+    getAttribution(assetId, assetName) {
+        return `## ${assetName}\n- Source: [AmbientCG](https://ambientcg.com/view?id=${assetId})\n- License: CC0 (Public Domain)\n- Downloaded: ${new Date().toISOString()}\n`;
+    }
+    async search(options) {
+        const { keyword, assetType, maxResults = 10 } = options;
+        let typeFilter = '';
+        if (assetType === 'textures') {
+            typeFilter = '&type=Material,Decal,Terrain';
+        }
+        else if (assetType === 'models') {
+            typeFilter = '&type=3DModel';
+        }
+        else if (assetType === 'hdris') {
+            typeFilter = '&type=HDRI';
+        }
+        const searchUrl = `${this.config.apiUrl}?q=${encodeURIComponent(keyword)}&limit=${maxResults}${typeFilter}&include=downloadData,previewData`;
+        try {
+            const responseText = await httpGet(searchUrl, this.config.userAgent);
+            const response = JSON.parse(responseText);
+            if (!response.foundAssets || response.foundAssets.length === 0) {
+                return [];
+            }
+            return response.foundAssets.map((asset, index) => {
+                const previewUrl = asset.previewImage?.['256-PNG'] || asset.previewImage?.['512-PNG'] || '';
+                return {
+                    id: asset.assetId,
+                    name: asset.assetId.replace(/_/g, ' '),
+                    provider: this.config.name,
+                    assetType: mapDataTypeToAssetType(asset.dataType),
+                    categories: asset.category ? [asset.category] : [],
+                    tags: asset.tags || [],
+                    license: 'CC0',
+                    previewUrl,
+                    downloadUrl: asset.downloadLink,
+                    score: 100 - index,
+                };
+            });
+        }
+        catch (error) {
+            console.error(`[AmbientCG] Search failed: ${error}`);
+            return [];
+        }
+    }
+    async download(options) {
+        const { assetId, projectPath, targetFolder = 'downloaded_assets/ambientcg', resolution = '2K' } = options;
+        const detailUrl = `${this.config.apiUrl}?id=${assetId}&include=downloadData`;
+        try {
+            const responseText = await httpGet(detailUrl, this.config.userAgent);
+            const response = JSON.parse(responseText);
+            if (!response.foundAssets || response.foundAssets.length === 0) {
+                throw new Error(`Asset not found: ${assetId}`);
+            }
+            const asset = response.foundAssets[0];
+            let downloadUrl = asset.downloadLink;
+            if (asset.rawLink) {
+                downloadUrl = asset.rawLink;
+            }
+            if (!downloadUrl) {
+                throw new Error(`No download URL for asset: ${assetId}`);
+            }
+            const targetDir = join(projectPath, targetFolder);
+            if (!existsSync(targetDir)) {
+                mkdirSync(targetDir, { recursive: true });
+            }
+            const fileName = `${assetId}.zip`;
+            const filePath = join(targetDir, fileName);
+            await downloadFile(downloadUrl, filePath, this.config.userAgent);
+            const creditsPath = join(targetDir, 'CREDITS.md');
+            const attribution = this.getAttribution(assetId, assetId);
+            if (existsSync(creditsPath)) {
+                appendFileSync(creditsPath, '\n' + attribution);
+            }
+            else {
+                writeFileSync(creditsPath, `# Asset Credits\n\nAssets downloaded from various CC0 sources\n\n${attribution}`);
+            }
+            return {
+                success: true,
+                assetId,
+                provider: this.config.name,
+                localPath: `${targetFolder}/${fileName}`,
+                fileName,
+                license: 'CC0',
+                attribution,
+                sourceUrl: `https://ambientcg.com/view?id=${assetId}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                assetId,
+                provider: this.config.name,
+                localPath: '',
+                fileName: '',
+                license: 'CC0',
+                attribution: '',
+                sourceUrl: `https://ambientcg.com/view?id=${assetId}`,
+            };
+        }
+    }
+}

package/build/providers/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './polyhaven.js';
+export * from './ambientcg.js';
+export * from './kenney.js';
+export * from './manager.js';

package/build/providers/kenney.js

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync, createWriteStream, appendFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import * as https from 'https';
+const KENNEY_CONFIG = {
+    name: 'kenney',
+    displayName: 'Kenney',
+    baseUrl: 'https://kenney.nl',
+    userAgent: 'GodotMCP/1.0',
+    priority: 3,
+    supportedTypes: ['models', 'textures', '2d', 'audio'],
+    requiresAuth: false,
+    license: 'CC0',
+};
+const KENNEY_ASSET_PACKS = [
+    { id: '3d-city', name: '3D City', category: 'Buildings', assetType: 'models', tags: ['city', 'urban', 'building', 'road', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/3d-city/2282f0a7e4-1728559116/kenney_3d-city.zip' },
+    { id: '3d-nature', name: '3D Nature Pack', category: 'Nature', assetType: 'models', tags: ['nature', 'tree', 'plant', 'rock', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/nature-kit/ed10aaba45-1728559116/kenney_nature-kit.zip' },
+    { id: 'furniture-kit', name: 'Furniture Kit', category: 'Interior', assetType: 'models', tags: ['furniture', 'chair', 'table', 'interior', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/furniture-kit/3e16e37fc1-1728559116/kenney_furniture-kit.zip' },
+    { id: 'tower-defense', name: 'Tower Defense Kit', category: 'Game', assetType: 'models', tags: ['tower', 'defense', 'game', 'strategy', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/tower-defense-kit/4a4ef34e87-1728559116/kenney_tower-defense-kit.zip' },
+    { id: 'medieval-rts', name: 'Medieval RTS', category: 'Medieval', assetType: 'models', tags: ['medieval', 'castle', 'knight', 'rts', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/medieval-rts/1c03b7bec3-1728559116/kenney_medieval-rts.zip' },
+    { id: 'racing-kit', name: 'Racing Kit', category: 'Vehicle', assetType: 'models', tags: ['car', 'racing', 'vehicle', 'road', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/racing-kit/94e7a5c4e8-1728559116/kenney_racing-kit.zip' },
+    { id: 'space-kit', name: 'Space Kit', category: 'Space', assetType: 'models', tags: ['space', 'rocket', 'planet', 'spaceship', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/space-kit/0c8c35e2c9-1728559116/kenney_space-kit.zip' },
+    { id: 'pirate-kit', name: 'Pirate Kit', category: 'Fantasy', assetType: 'models', tags: ['pirate', 'ship', 'treasure', 'island', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/pirate-kit/8f0ced50f7-1728559116/kenney_pirate-kit.zip' },
+    { id: 'food-kit', name: 'Food Kit', category: 'Props', assetType: 'models', tags: ['food', 'fruit', 'vegetable', 'kitchen', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/food-kit/9d0a0bf3d7-1728559116/kenney_food-kit.zip' },
+    { id: 'holiday-kit', name: 'Holiday Kit', category: 'Holiday', assetType: 'models', tags: ['christmas', 'holiday', 'decoration', 'winter', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/holiday-kit/b1c8fe2d1f-1728559116/kenney_holiday-kit.zip' },
+    { id: 'platformer-kit', name: 'Platformer Kit', category: 'Game', assetType: 'models', tags: ['platformer', 'game', 'tiles', 'character', 'low-poly'], downloadUrl: 'https://kenney.nl/media/pages/assets/platformer-kit/f3a7e8d2c1-1728559116/kenney_platformer-kit.zip' },
+    { id: 'monochrome-rpg', name: 'Monochrome RPG', category: '2D', assetType: '2d', tags: ['rpg', 'pixel', 'monochrome', 'character', 'tileset'], downloadUrl: 'https://kenney.nl/media/pages/assets/monochrome-rpg/8d3b2f1e4a-1728559116/kenney_monochrome-rpg.zip' },
+    { id: 'tiny-dungeon', name: 'Tiny Dungeon', category: '2D', assetType: '2d', tags: ['dungeon', 'pixel', 'tiles', 'character', 'fantasy'], downloadUrl: 'https://kenney.nl/media/pages/assets/tiny-dungeon/a2c4e6f8d0-1728559116/kenney_tiny-dungeon.zip' },
+    { id: 'particle-pack', name: 'Particle Pack', category: 'Effects', assetType: 'textures', tags: ['particle', 'effect', 'smoke', 'fire', 'explosion'], downloadUrl: 'https://kenney.nl/media/pages/assets/particle-pack/1b3d5f7a9c-1728559116/kenney_particle-pack.zip' },
+    { id: 'ui-pack', name: 'UI Pack', category: 'UI', assetType: '2d', tags: ['ui', 'button', 'interface', 'menu', 'icon'], downloadUrl: 'https://kenney.nl/media/pages/assets/ui-pack/e4f6a8c0d2-1728559116/kenney_ui-pack.zip' },
+    { id: 'impact-sounds', name: 'Impact Sounds', category: 'Audio', assetType: 'audio', tags: ['impact', 'sound', 'effect', 'hit', 'sfx'], downloadUrl: 'https://kenney.nl/media/pages/assets/impact-sounds/5d7f9a1c3e-1728559116/kenney_impact-sounds.zip' },
+    { id: 'rpg-sounds', name: 'RPG Sounds', category: 'Audio', assetType: 'audio', tags: ['rpg', 'sound', 'effect', 'game', 'sfx'], downloadUrl: 'https://kenney.nl/media/pages/assets/rpg-audio/b6d8e0f2a4-1728559116/kenney_rpg-audio.zip' },
+];
+function downloadFile(url, destPath, userAgent) {
+    return new Promise((resolve, reject) => {
+        const file = createWriteStream(destPath);
+        const request = (currentUrl) => {
+            https.get(currentUrl, { headers: { 'User-Agent': userAgent } }, (response) => {
+                if (response.statusCode === 301 || response.statusCode === 302) {
+                    const redirectUrl = response.headers.location;
+                    if (redirectUrl) {
+                        request(redirectUrl);
+                        return;
+                    }
+                }
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            }).on('error', (err) => {
+                file.close();
+                reject(err);
+            });
+        };
+        request(url);
+    });
+}
+export class KenneyProvider {
+    config = KENNEY_CONFIG;
+    supportsType(type) {
+        return this.config.supportedTypes.includes(type);
+    }
+    getAttribution(assetId, assetName) {
+        return `## ${assetName}\n- Source: [Kenney](https://kenney.nl/assets/${assetId})\n- License: CC0 (Public Domain)\n- Downloaded: ${new Date().toISOString()}\n`;
+    }
+    async search(options) {
+        const { keyword, assetType, maxResults = 10 } = options;
+        const keywordLower = keyword.toLowerCase();
+        let filtered = KENNEY_ASSET_PACKS;
+        if (assetType) {
+            filtered = filtered.filter(pack => pack.assetType === assetType);
+        }
+        const scored = filtered.map(pack => {
+            let score = 0;
+            if (pack.id.toLowerCase().includes(keywordLower))
+                score += 100;
+            if (pack.name.toLowerCase().includes(keywordLower))
+                score += 80;
+            if (pack.category.toLowerCase().includes(keywordLower))
+                score += 50;
+            for (const tag of pack.tags) {
+                if (tag.toLowerCase().includes(keywordLower))
+                    score += 30;
+            }
+            return { ...pack, score };
+        });
+        const matches = scored
+            .filter(pack => pack.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, maxResults);
+        return matches.map(pack => ({
+            id: pack.id,
+            name: pack.name,
+            provider: this.config.name,
+            assetType: pack.assetType,
+            categories: [pack.category],
+            tags: pack.tags,
+            license: 'CC0',
+            previewUrl: `https://kenney.nl/media/pages/assets/${pack.id}/preview.png`,
+            downloadUrl: pack.downloadUrl,
+            score: pack.score,
+        }));
+    }
+    async download(options) {
+        const { assetId, projectPath, targetFolder = 'downloaded_assets/kenney' } = options;
+        const pack = KENNEY_ASSET_PACKS.find(p => p.id === assetId);
+        if (!pack) {
+            return {
+                success: false,
+                assetId,
+                provider: this.config.name,
+                localPath: '',
+                fileName: '',
+                license: 'CC0',
+                attribution: '',
+                sourceUrl: `https://kenney.nl/assets/${assetId}`,
+            };
+        }
+        try {
+            const targetDir = join(projectPath, targetFolder);
+            if (!existsSync(targetDir)) {
+                mkdirSync(targetDir, { recursive: true });
+            }
+            const fileName = `kenney_${assetId}.zip`;
+            const filePath = join(targetDir, fileName);
+            await downloadFile(pack.downloadUrl, filePath, this.config.userAgent);
+            const creditsPath = join(targetDir, 'CREDITS.md');
+            const attribution = this.getAttribution(assetId, pack.name);
+            if (existsSync(creditsPath)) {
+                appendFileSync(creditsPath, '\n' + attribution);
+            }
+            else {
+                writeFileSync(creditsPath, `# Asset Credits\n\nAssets downloaded from Kenney (CC0 License)\n\n${attribution}`);
+            }
+            return {
+                success: true,
+                assetId,
+                provider: this.config.name,
+                localPath: `${targetFolder}/${fileName}`,
+                fileName,
+                license: 'CC0',
+                attribution,
+                sourceUrl: `https://kenney.nl/assets/${assetId}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                assetId,
+                provider: this.config.name,
+                localPath: '',
+                fileName: '',
+                license: 'CC0',
+                attribution: '',
+                sourceUrl: `https://kenney.nl/assets/${assetId}`,
+            };
+        }
+    }
+}

package/build/providers/manager.js

@@ -0,0 +1,122 @@
+import { PROVIDER_PRIORITY, } from './types.js';
+import { PolyHavenProvider } from './polyhaven.js';
+import { AmbientCGProvider } from './ambientcg.js';
+import { KenneyProvider } from './kenney.js';
+export class AssetManager {
+    providers = new Map();
+    sortedProviders = [];
+    constructor() {
+        this.registerProvider(new PolyHavenProvider());
+        this.registerProvider(new AmbientCGProvider());
+        this.registerProvider(new KenneyProvider());
+        this.sortProvidersByPriority();
+    }
+    registerProvider(provider) {
+        this.providers.set(provider.config.name, provider);
+    }
+    sortProvidersByPriority() {
+        this.sortedProviders = Array.from(this.providers.values()).sort((a, b) => (PROVIDER_PRIORITY[a.config.name] || 99) - (PROVIDER_PRIORITY[b.config.name] || 99));
+    }
+    getProviderNames() {
+        return this.sortedProviders.map(p => p.config.name);
+    }
+    getProviderInfo() {
+        return this.sortedProviders.map(p => ({
+            name: p.config.name,
+            displayName: p.config.displayName,
+            priority: p.config.priority,
+            types: p.config.supportedTypes,
+        }));
+    }
+    async searchAll(options) {
+        const { assetType, maxResults = 10 } = options;
+        const allResults = [];
+        for (const provider of this.sortedProviders) {
+            if (assetType && !provider.supportsType(assetType)) {
+                continue;
+            }
+            try {
+                const results = await provider.search(options);
+                allResults.push(...results);
+            }
+            catch (error) {
+                console.error(`[AssetManager] Search failed for ${provider.config.name}: ${error}`);
+            }
+        }
+        return allResults
+            .sort((a, b) => {
+            const priorityA = PROVIDER_PRIORITY[a.provider] || 99;
+            const priorityB = PROVIDER_PRIORITY[b.provider] || 99;
+            if (priorityA !== priorityB)
+                return priorityA - priorityB;
+            return b.score - a.score;
+        })
+            .slice(0, maxResults);
+    }
+    async searchSequential(options) {
+        const { assetType, maxResults = 5 } = options;
+        for (const provider of this.sortedProviders) {
+            if (assetType && !provider.supportsType(assetType)) {
+                continue;
+            }
+            try {
+                const results = await provider.search({ ...options, maxResults });
+                if (results.length > 0) {
+                    return results;
+                }
+            }
+            catch (error) {
+                console.error(`[AssetManager] Search failed for ${provider.config.name}: ${error}`);
+            }
+        }
+        return [];
+    }
+    async searchProvider(providerName, options) {
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+            throw new Error(`Provider not found: ${providerName}`);
+        }
+        return provider.search(options);
+    }
+    async download(options) {
+        const { provider: providerName, assetId } = options;
+        if (providerName) {
+            const provider = this.providers.get(providerName);
+            if (!provider) {
+                return {
+                    success: false,
+                    assetId,
+                    provider: providerName,
+                    localPath: '',
+                    fileName: '',
+                    license: '',
+                    attribution: '',
+                    sourceUrl: '',
+                };
+            }
+            return provider.download(options);
+        }
+        for (const provider of this.sortedProviders) {
+            try {
+                const result = await provider.download(options);
+                if (result.success) {
+                    return result;
+                }
+            }
+            catch (error) {
+                console.error(`[AssetManager] Download failed for ${provider.config.name}: ${error}`);
+            }
+        }
+        return {
+            success: false,
+            assetId,
+            provider: 'unknown',
+            localPath: '',
+            fileName: '',
+            license: '',
+            attribution: '',
+            sourceUrl: '',
+        };
+    }
+}
+export const assetManager = new AssetManager();

package/build/providers/polyhaven.js

@@ -0,0 +1,191 @@
+import { existsSync, mkdirSync, createWriteStream, appendFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import * as https from 'https';
+const POLYHAVEN_CONFIG = {
+    name: 'polyhaven',
+    displayName: 'Poly Haven',
+    baseUrl: 'https://polyhaven.com',
+    apiUrl: 'https://api.polyhaven.com',
+    userAgent: 'GodotMCP/1.0',
+    priority: 1,
+    supportedTypes: ['models', 'textures', 'hdris'],
+    requiresAuth: false,
+    license: 'CC0',
+};
+function httpGet(url, userAgent) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { headers: { 'User-Agent': userAgent } }, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                const redirectUrl = res.headers.location;
+                if (redirectUrl) {
+                    httpGet(redirectUrl, userAgent).then(resolve).catch(reject);
+                    return;
+                }
+            }
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => resolve(data));
+        }).on('error', reject);
+    });
+}
+function downloadFile(url, destPath, userAgent) {
+    return new Promise((resolve, reject) => {
+        const file = createWriteStream(destPath);
+        const request = (currentUrl) => {
+            https.get(currentUrl, { headers: { 'User-Agent': userAgent } }, (response) => {
+                if (response.statusCode === 301 || response.statusCode === 302) {
+                    const redirectUrl = response.headers.location;
+                    if (redirectUrl) {
+                        request(redirectUrl);
+                        return;
+                    }
+                }
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            }).on('error', (err) => {
+                file.close();
+                reject(err);
+            });
+        };
+        request(url);
+    });
+}
+function mapAssetTypeToApiParam(type) {
+    switch (type) {
+        case 'models': return 'models';
+        case 'textures': return 'textures';
+        case 'hdris': return 'hdris';
+        default: return 'models';
+    }
+}
+export class PolyHavenProvider {
+    config = POLYHAVEN_CONFIG;
+    supportsType(type) {
+        return this.config.supportedTypes.includes(type);
+    }
+    getAttribution(assetId, assetName) {
+        return `## ${assetName}\n- Source: [Poly Haven](https://polyhaven.com/a/${assetId})\n- License: CC0 (Public Domain)\n- Downloaded: ${new Date().toISOString()}\n`;
+    }
+    async search(options) {
+        const { keyword, assetType = 'models', maxResults = 10 } = options;
+        const apiType = mapAssetTypeToApiParam(assetType);
+        const searchUrl = `${this.config.apiUrl}/assets?t=${apiType}`;
+        try {
+            const responseText = await httpGet(searchUrl, this.config.userAgent);
+            const allAssets = JSON.parse(responseText);
+            const keywordLower = keyword.toLowerCase();
+            const matches = [];
+            for (const [assetId, assetData] of Object.entries(allAssets)) {
+                let score = 0;
+                if (assetId.toLowerCase().includes(keywordLower))
+                    score += 100;
+                if (assetData.name?.toLowerCase().includes(keywordLower))
+                    score += 80;
+                if (assetData.tags) {
+                    for (const tag of assetData.tags) {
+                        if (tag.toLowerCase().includes(keywordLower))
+                            score += 50;
+                    }
+                }
+                if (assetData.categories) {
+                    for (const cat of assetData.categories) {
+                        if (cat.toLowerCase().includes(keywordLower))
+                            score += 30;
+                    }
+                }
+                if (score > 0) {
+                    matches.push({
+                        id: assetId,
+                        name: assetData.name || assetId,
+                        provider: this.config.name,
+                        assetType,
+                        categories: assetData.categories || [],
+                        tags: assetData.tags || [],
+                        license: 'CC0',
+                        previewUrl: `https://cdn.polyhaven.com/asset_img/thumbs/${assetId}.png`,
+                        score,
+                    });
+                }
+            }
+            return matches
+                .sort((a, b) => b.score - a.score)
+                .slice(0, maxResults);
+        }
+        catch (error) {
+            console.error(`[PolyHaven] Search failed: ${error}`);
+            return [];
+        }
+    }
+    async download(options) {
+        const { assetId, projectPath, targetFolder = 'downloaded_assets/polyhaven', resolution = '2k', format, } = options;
+        try {
+            const fileInfoUrl = `${this.config.apiUrl}/files/${assetId}`;
+            const responseText = await httpGet(fileInfoUrl, this.config.userAgent);
+            const fileInfo = JSON.parse(responseText);
+            let downloadUrl = '';
+            let fileExtension = '.glb';
+            let detectedType = 'models';
+            if (fileInfo.gltf) {
+                detectedType = 'models';
+                const res = fileInfo.gltf[resolution] || fileInfo.gltf[Object.keys(fileInfo.gltf)[0]];
+                downloadUrl = res?.gltf?.url || '';
+                fileExtension = '.glb';
+            }
+            else if (fileInfo.Diffuse) {
+                detectedType = 'textures';
+                const res = fileInfo.Diffuse[resolution] || fileInfo.Diffuse[Object.keys(fileInfo.Diffuse)[0]];
+                downloadUrl = res?.png?.url || '';
+                fileExtension = '.png';
+            }
+            else if (fileInfo.hdri) {
+                detectedType = 'hdris';
+                const res = fileInfo.hdri[resolution] || fileInfo.hdri[Object.keys(fileInfo.hdri)[0]];
+                downloadUrl = res?.hdr?.url || '';
+                fileExtension = '.hdr';
+            }
+            if (!downloadUrl) {
+                throw new Error(`No download URL found for asset: ${assetId}`);
+            }
+            const targetDir = join(projectPath, targetFolder);
+            if (!existsSync(targetDir)) {
+                mkdirSync(targetDir, { recursive: true });
+            }
+            const fileName = `${assetId}${fileExtension}`;
+            const filePath = join(targetDir, fileName);
+            await downloadFile(downloadUrl, filePath, this.config.userAgent);
+            const creditsPath = join(targetDir, 'CREDITS.md');
+            const attribution = this.getAttribution(assetId, assetId);
+            if (existsSync(creditsPath)) {
+                appendFileSync(creditsPath, '\n' + attribution);
+            }
+            else {
+                writeFileSync(creditsPath, `# Asset Credits\n\nAssets downloaded from Poly Haven (CC0 License)\n\n${attribution}`);
+            }
+            return {
+                success: true,
+                assetId,
+                provider: this.config.name,
+                localPath: `${targetFolder}/${fileName}`,
+                fileName,
+                license: 'CC0',
+                attribution,
+                sourceUrl: `https://polyhaven.com/a/${assetId}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                assetId,
+                provider: this.config.name,
+                localPath: '',
+                fileName: '',
+                license: 'CC0',
+                attribution: '',
+                sourceUrl: `https://polyhaven.com/a/${assetId}`,
+            };
+        }
+    }
+}

package/build/providers/types.js

@@ -0,0 +1,19 @@
+/**
+ * Asset Provider Interface & Types
+ *
+ * This module defines the common interface for all asset providers (Poly Haven, AmbientCG, etc.)
+ * enabling a unified multi-source asset search and download system.
+ */
+/**
+ * Provider priority order (used for sequential search)
+ */
+export const PROVIDER_PRIORITY = {
+    'polyhaven': 1,
+    'ambientcg': 2,
+    'kenney': 3,
+    'cc0lib': 4,
+    'quaternius': 5,
+    'nasa3d': 6,
+    'opengameart': 7,
+    'smithsonian': 8,
+};