@series-inc/stowkit-cli 0.6.35 → 0.6.37

package/dist/ai-tagger.d.ts

@@ -0,0 +1,13 @@
+import { AssetType } from './core/types.js';
+/**
+ * Verify that a Gemini API key is valid by making a minimal request.
+ */
+export declare function verifyApiKey(apiKey: string): Promise<{
+    valid: boolean;
+    error?: string;
+}>;
+/**
+ * Tag a single asset by sending its thumbnail/audio to Gemini.
+ * Returns an array of lowercase tag strings.
+ */
+export declare function tagAsset(apiKey: string, assetType: AssetType, fileName: string, inputData: Buffer, mimeType: string): Promise<string[]>;

package/dist/ai-tagger.js

@@ -0,0 +1,95 @@
+import { GoogleGenAI } from '@google/genai';
+import { AssetType } from './core/types.js';
+const MODEL = 'gemini-3.1-flash-lite-preview';
+const ASSET_TYPE_LABELS = {
+    [AssetType.Texture2D]: 'texture',
+    [AssetType.StaticMesh]: '3D mesh',
+    [AssetType.SkinnedMesh]: 'skinned 3D mesh',
+    [AssetType.AnimationClip]: 'animation',
+    [AssetType.Audio]: 'audio clip',
+    [AssetType.GlbContainer]: '3D model',
+};
+function buildPrompt(assetType, fileName) {
+    const label = ASSET_TYPE_LABELS[assetType] ?? 'asset';
+    return `You are a strict asset tagging engine for a game development library.
+
+This is a game ${label} (${fileName}).
+
+Return only a JSON array of concise lowercase asset tags.
+
+Rules:
+- 4 to 12 tags
+- lowercase only
+- no duplicates
+- short searchable tags only
+- no explanations
+- no generic tags like asset, file, media, content
+- only include tags directly supported by the input`;
+}
+/**
+ * Verify that a Gemini API key is valid by making a minimal request.
+ */
+export async function verifyApiKey(apiKey) {
+    try {
+        const client = new GoogleGenAI({ apiKey });
+        const response = await client.models.generateContent({
+            model: MODEL,
+            contents: [{ role: 'user', parts: [{ text: 'Respond with the word "ok"' }] }],
+            config: { maxOutputTokens: 10 },
+        });
+        const text = response.text?.trim().toLowerCase() ?? '';
+        return { valid: text.includes('ok') };
+    }
+    catch (err) {
+        return { valid: false, error: err.message };
+    }
+}
+/**
+ * Tag a single asset by sending its thumbnail/audio to Gemini.
+ * Returns an array of lowercase tag strings.
+ */
+export async function tagAsset(apiKey, assetType, fileName, inputData, mimeType) {
+    const client = new GoogleGenAI({ apiKey });
+    const response = await client.models.generateContent({
+        model: MODEL,
+        contents: [{
+                role: 'user',
+                parts: [
+                    { text: buildPrompt(assetType, fileName) },
+                    {
+                        inlineData: {
+                            data: inputData.toString('base64'),
+                            mimeType,
+                        },
+                    },
+                ],
+            }],
+        config: {
+            temperature: 0.3,
+            topP: 0.95,
+            maxOutputTokens: 1024,
+            responseMimeType: 'application/json',
+            responseSchema: {
+                type: 'ARRAY',
+                items: { type: 'STRING' },
+                minItems: 4,
+                maxItems: 12,
+            },
+            safetySettings: [
+                { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'OFF' },
+                { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'OFF' },
+                { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'OFF' },
+                { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'OFF' },
+            ],
+            thinkingConfig: { thinkingBudget: 0 },
+        },
+    });
+    const text = response.text ?? '[]';
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed))
+        return [];
+    return parsed
+        .filter((t) => typeof t === 'string')
+        .map((t) => t.toLowerCase().trim())
+        .filter((t) => t.length > 0);
+}

package/dist/app/disk-project.d.ts

@@ -27,6 +27,9 @@ export interface FelicityProject {
     prefabsPath?: string;
     packs?: PackConfig[];
     defaults?: ProjectDefaults;
+    ai?: {
+        geminiApiKey?: string;
+    };
 }
 export interface FileSnapshot {
     relativePath: string;

package/dist/cli.js

@@ -11,7 +11,6 @@ import { createMaterial } from './create-material.js';
 import { renameAsset, moveAsset, deleteAsset, setStringId } from './asset-commands.js';
 import { inspectPack } from './inspect.js';
 import { publishPackage } from './publish.js';
-import { storeSearch, storeList, storeInfo } from './store.js';
 const args = process.argv.slice(2);
 const thisDir = path.dirname(fileURLToPath(import.meta.url));
 const STOWKIT_PACKAGES = [
@@ -108,7 +107,6 @@ Options:
   --schema      Material schema template: pbr (default), unlit, or custom name
   --bucket      GCS bucket for publish/store (overrides default)
   --dry-run     Show what would be published without uploading
-  --json        Output store results as JSON (for AI agents)
   --type        Filter store search by asset type
   --limit       Max number of results to return (default: all)
   --help        Show this help message
@@ -163,7 +161,6 @@ async function main() {
     const portIdx = args.indexOf('--port');
     const port = portIdx >= 0 ? parseInt(args[portIdx + 1]) : 3210;
     const dryRun = args.includes('--dry-run');
-    const jsonOutput = args.includes('--json');
     const bucketIdx = args.indexOf('--bucket');
     const bucket = bucketIdx >= 0 ? args[bucketIdx + 1] : undefined;
     const typeIdx = args.indexOf('--type');
@@ -306,35 +303,29 @@ async function main() {
                 const subCmd = args[1];
                 const serverUrl = `http://localhost:${port}`;
                 const serverUp = await isStowKitRunning(port);
+                if (!serverUp) {
+                    console.error('StowKit server is not running. Start it with: stowkit serve');
+                    process.exit(1);
+                }
                 if (subCmd === 'search') {
                     const query = args.filter(a => !a.startsWith('-') && a !== 'store' && a !== 'search').join(' ');
                     if (!query) {
-                        console.error('Usage: stowkit store search <query> [--type <type>] [--limit <n>] [--json]');
+                        console.error('Usage: stowkit store search <query> [--type <type>] [--limit <n>]');
                         process.exit(1);
                     }
-                    if (serverUp) {
-                        const params = new URLSearchParams({ q: query });
-                        if (typeFilter)
-                            params.set('type', typeFilter);
-                        if (limitFilter)
-                            params.set('limit', String(limitFilter));
-                        const res = await fetch(`${serverUrl}/api/asset-store/search?${params}`);
-                        const results = await res.json();
-                        console.log(JSON.stringify(results, null, 2));
-                    }
-                    else {
-                        await storeSearch(query, { json: jsonOutput, bucket, type: typeFilter, limit: limitFilter });
-                    }
+                    const params = new URLSearchParams({ q: query });
+                    if (typeFilter)
+                        params.set('type', typeFilter);
+                    if (limitFilter)
+                        params.set('limit', String(limitFilter));
+                    const res = await fetch(`${serverUrl}/api/asset-store/search?${params}`);
+                    const results = await res.json();
+                    console.log(JSON.stringify(results, null, 2));
                 }
                 else if (subCmd === 'list') {
-                    if (serverUp) {
-                        const res = await fetch(`${serverUrl}/api/asset-store/packages`);
-                        const packages = await res.json();
-                        console.log(JSON.stringify(packages, null, 2));
-                    }
-                    else {
-                        await storeList({ json: jsonOutput, bucket });
-                    }
+                    const res = await fetch(`${serverUrl}/api/asset-store/packages`);
+                    const packages = await res.json();
+                    console.log(JSON.stringify(packages, null, 2));
                 }
                 else if (subCmd === 'info') {
                     const pkgName = args.find(a => !a.startsWith('-') && a !== 'store' && a !== 'info');
@@ -342,14 +333,9 @@ async function main() {
                         console.error('Usage: stowkit store info <package-name> [--json]');
                         process.exit(1);
                     }
-                    if (serverUp) {
-                        const res = await fetch(`${serverUrl}/api/asset-store/package/${encodeURIComponent(pkgName)}`);
-                        const info = await res.json();
-                        console.log(JSON.stringify(info, null, 2));
-                    }
-                    else {
-                        await storeInfo(pkgName, { json: jsonOutput, bucket });
-                    }
+                    const res = await fetch(`${serverUrl}/api/asset-store/package/${encodeURIComponent(pkgName)}`);
+                    const info = await res.json();
+                    console.log(JSON.stringify(info, null, 2));
                 }
                 else {
                     console.error('Usage: stowkit store <search|list|info> [args]');

package/dist/firestore.js

@@ -70,6 +70,23 @@ function objectToFields(data) {
     }
     return fields;
 }
+// ─── In-memory cache ─────────────────────────────────────────────────────────
+const CACHE_TTL_MS = 60_000; // 1 minute
+const cache = new Map();
+function cacheGet(key) {
+    const entry = cache.get(key);
+    if (!entry)
+        return undefined;
+    if (Date.now() > entry.expiry) {
+        cache.delete(key);
+        return undefined;
+    }
+    return entry.value;
+}
+function cacheSet(key, value) {
+    cache.set(key, { value, expiry: Date.now() + CACHE_TTL_MS });
+    return value;
+}
 // ─── REST helpers ────────────────────────────────────────────────────────────
 const BASE = 'https://firestore.googleapis.com/v1';
 function docPath(projectId, ...segments) {
@@ -78,17 +95,25 @@ function docPath(projectId, ...segments) {
 // ─── Shared read operations ─────────────────────────────────────────────────
 function buildReadOps(projectId, fetchWithAuth) {
     async function getPackage(name) {
+        const key = `pkg:${projectId}:${name}`;
+        const cached = cacheGet(key);
+        if (cached !== undefined)
+            return cached;
         const res = await fetchWithAuth(docPath(projectId, 'packages', name));
         if (res.status === 404)
-            return null;
+            return cacheSet(key, null);
         if (!res.ok) {
             const text = await res.text();
             throw new Error(`Firestore GET packages/${name} failed (${res.status}): ${text}`);
         }
         const doc = (await res.json());
-        return docToObject(doc.fields);
+        return cacheSet(key, docToObject(doc.fields));
     }
     async function listPackages() {
+        const key = `pkgList:${projectId}`;
+        const cached = cacheGet(key);
+        if (cached)
+            return cached;
         const results = [];
         let pageToken;
         do {
@@ -111,20 +136,28 @@ function buildReadOps(projectId, fetchWithAuth) {
             }
             pageToken = body.nextPageToken;
         } while (pageToken);
-        return results;
+        return cacheSet(key, results);
     }
     async function getVersion(packageName, version) {
+        const key = `ver:${projectId}:${packageName}:${version}`;
+        const cached = cacheGet(key);
+        if (cached !== undefined)
+            return cached;
         const res = await fetchWithAuth(docPath(projectId, 'packages', packageName, 'versions', version));
         if (res.status === 404)
-            return null;
+            return cacheSet(key, null);
         if (!res.ok) {
             const text = await res.text();
             throw new Error(`Firestore GET packages/${packageName}/versions/${version} failed (${res.status}): ${text}`);
         }
         const doc = (await res.json());
-        return docToObject(doc.fields);
+        return cacheSet(key, docToObject(doc.fields));
     }
     async function listVersionKeys(packageName) {
+        const key = `verKeys:${projectId}:${packageName}`;
+        const cached = cacheGet(key);
+        if (cached)
+            return cached;
         const results = [];
         let pageToken;
         do {
@@ -144,7 +177,7 @@ function buildReadOps(projectId, fetchWithAuth) {
             }
             pageToken = body.nextPageToken;
         } while (pageToken);
-        return results;
+        return cacheSet(key, results);
     }
     return { getPackage, listPackages, getVersion, listVersionKeys };
 }

package/dist/server.js

@@ -1608,6 +1608,15 @@ async function handleRequest(req, res, staticApps) {
         if (Object.prototype.hasOwnProperty.call(body, 'defaults')) {
             nextConfig.defaults = normalizeProjectDefaults(body.defaults);
         }
+        if (Object.prototype.hasOwnProperty.call(body, 'ai')) {
+            const aiBody = body.ai;
+            if (aiBody && typeof aiBody.geminiApiKey === 'string' && aiBody.geminiApiKey.trim()) {
+                nextConfig.ai = { geminiApiKey: aiBody.geminiApiKey.trim() };
+            }
+            else {
+                nextConfig.ai = undefined;
+            }
+        }
         const renamedPacks = Array.isArray(body.renamedPacks)
             ? body.renamedPacks.filter((rename) => typeof rename?.oldName === 'string'
                 && typeof rename?.newName === 'string'
@@ -1783,14 +1792,17 @@ async function handleRequest(req, res, staticApps) {
             const { createFirestoreReader } = await import('./firestore.js');
             const reader = createFirestoreReader();
             const allPackages = await reader.listPackages();
+            // Fetch all version keys in parallel
+            const allVersionKeys = await Promise.all(allPackages.map(({ name }) => reader.listVersionKeys(name)));
+            // Fetch all version docs in parallel
+            const allVersionDocs = await Promise.all(allPackages.map(({ name }, i) => Promise.all(allVersionKeys[i].map(ver => reader.getVersion(name, ver).then(doc => ({ ver, doc }))))));
             const packages = {};
-            for (const { name, data: pkg } of allPackages) {
-                const versionKeys = await reader.listVersionKeys(name);
+            for (let i = 0; i < allPackages.length; i++) {
+                const { name, data: pkg } = allPackages[i];
                 const versions = {};
-                for (const ver of versionKeys) {
-                    const versionDoc = await reader.getVersion(name, ver);
-                    if (versionDoc)
-                        versions[ver] = versionDoc;
+                for (const { ver, doc } of allVersionDocs[i]) {
+                    if (doc)
+                        versions[ver] = doc;
                 }
                 packages[name] = {
                     description: pkg.description,
@@ -2011,6 +2023,267 @@ async function handleRequest(req, res, staticApps) {
         }
         return;
     }
+    // POST /api/ai/verify-key — validate a Gemini API key
+    if (pathname === '/api/ai/verify-key' && req.method === 'POST') {
+        try {
+            const body = JSON.parse(await readBody(req));
+            const apiKey = body.apiKey;
+            if (!apiKey || typeof apiKey !== 'string') {
+                json(res, { valid: false, error: 'Missing apiKey' });
+                return;
+            }
+            const { verifyApiKey } = await import('./ai-tagger.js');
+            const result = await verifyApiKey(apiKey);
+            json(res, result);
+        }
+        catch (err) {
+            json(res, { valid: false, error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/ai/tag/:id — AI-tag a single asset
+    if (pathname.startsWith('/api/ai/tag/') && req.method === 'POST' && !pathname.endsWith('/tag-missing')) {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const apiKey = projectConfig.config.ai?.geminiApiKey;
+        if (!apiKey) {
+            json(res, { error: 'Gemini API key not configured' }, 400);
+            return;
+        }
+        const id = decodeURIComponent(pathname.slice('/api/ai/tag/'.length));
+        const asset = assets.find(a => a.id === id);
+        if (!asset) {
+            json(res, { error: 'Asset not found' }, 404);
+            return;
+        }
+        if (asset.type === AssetType.MaterialSchema) {
+            json(res, { error: 'Material schemas cannot be tagged' }, 400);
+            return;
+        }
+        try {
+            const { tagAsset: aiTagAsset } = await import('./ai-tagger.js');
+            let inputData;
+            let mimeType;
+            if (asset.type === AssetType.Audio) {
+                const ext = asset.fileName.split('.').pop()?.toLowerCase() ?? 'wav';
+                const mimeMap = {
+                    wav: 'audio/wav', mp3: 'audio/mpeg', ogg: 'audio/ogg',
+                    flac: 'audio/flac', aac: 'audio/aac', m4a: 'audio/mp4',
+                };
+                mimeType = mimeMap[ext] ?? 'audio/wav';
+                const raw = await readFile(projectConfig.srcArtDir, id);
+                if (!raw) {
+                    json(res, { error: 'Source audio file not found' }, 404);
+                    return;
+                }
+                inputData = Buffer.from(raw);
+            }
+            else {
+                const { readManifest, readThumbnailFile } = await import('./app/thumbnail-cache.js');
+                const manifest = await readManifest(projectConfig.srcArtDir);
+                const entry = manifest[asset.stringId];
+                if (!entry) {
+                    json(res, { error: 'No cached thumbnail — capture thumbnails first' }, 400);
+                    return;
+                }
+                const thumbData = await readThumbnailFile(projectConfig.srcArtDir, asset.stringId, entry.format);
+                if (!thumbData) {
+                    json(res, { error: 'Thumbnail file missing from cache' }, 400);
+                    return;
+                }
+                inputData = thumbData;
+                const formatMime = {
+                    png: 'image/png', webp: 'image/webp', webm: 'video/webm',
+                };
+                mimeType = formatMime[entry.format] ?? 'image/webp';
+            }
+            const newTags = await aiTagAsset(apiKey, asset.type, asset.fileName, inputData, mimeType);
+            const existingTags = asset.settings.tags ?? [];
+            const merged = [...new Set([...existingTags, ...newTags])];
+            asset.settings = { ...asset.settings, tags: merged };
+            if (!asset.parentId) {
+                const meta = assetSettingsToStowmeta(asset);
+                await writeStowmeta(projectConfig.srcArtDir, id, meta);
+            }
+            broadcast({ type: 'asset-update', id, updates: { settings: asset.settings } });
+            json(res, { tags: merged });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/ai/tag-missing — bulk AI-tag all assets with empty tags
+    if (pathname === '/api/ai/tag-missing' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const apiKey = projectConfig.config.ai?.geminiApiKey;
+        if (!apiKey) {
+            json(res, { error: 'Gemini API key not configured' }, 400);
+            return;
+        }
+        try {
+            const { tagAsset: aiTagAsset } = await import('./ai-tagger.js');
+            const { readManifest, readThumbnailFile } = await import('./app/thumbnail-cache.js');
+            const manifest = await readManifest(projectConfig.srcArtDir);
+            const eligible = assets.filter(a => a.status === 'ready' &&
+                !a.settings.excluded &&
+                (!a.settings.tags || a.settings.tags.length === 0) &&
+                a.type !== AssetType.MaterialSchema &&
+                !a.parentId);
+            let tagged = 0;
+            let skipped = 0;
+            const errors = [];
+            for (const asset of eligible) {
+                try {
+                    let inputData;
+                    let mimeType;
+                    if (asset.type === AssetType.Audio) {
+                        const ext = asset.fileName.split('.').pop()?.toLowerCase() ?? 'wav';
+                        const mimeMap = {
+                            wav: 'audio/wav', mp3: 'audio/mpeg', ogg: 'audio/ogg',
+                            flac: 'audio/flac', aac: 'audio/aac', m4a: 'audio/mp4',
+                        };
+                        mimeType = mimeMap[ext] ?? 'audio/wav';
+                        const raw = await readFile(projectConfig.srcArtDir, asset.id);
+                        if (!raw) {
+                            skipped++;
+                            continue;
+                        }
+                        inputData = Buffer.from(raw);
+                    }
+                    else {
+                        const entry = manifest[asset.stringId];
+                        if (!entry) {
+                            skipped++;
+                            continue;
+                        }
+                        const thumbData = await readThumbnailFile(projectConfig.srcArtDir, asset.stringId, entry.format);
+                        if (!thumbData) {
+                            skipped++;
+                            continue;
+                        }
+                        inputData = thumbData;
+                        const formatMime = {
+                            png: 'image/png', webp: 'image/webp', webm: 'video/webm',
+                        };
+                        mimeType = formatMime[entry.format] ?? 'image/webp';
+                    }
+                    const tagPromise = aiTagAsset(apiKey, asset.type, asset.fileName, inputData, mimeType);
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Gemini request timed out (30s)')), 30_000));
+                    const newTags = await Promise.race([tagPromise, timeoutPromise]);
+                    asset.settings = { ...asset.settings, tags: newTags };
+                    if (!asset.parentId) {
+                        const meta = assetSettingsToStowmeta(asset);
+                        await writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
+                    }
+                    broadcast({ type: 'asset-update', id: asset.id, updates: { settings: asset.settings } });
+                    tagged++;
+                    await new Promise(r => setTimeout(r, 200));
+                }
+                catch (err) {
+                    errors.push({ id: asset.id, error: err.message });
+                }
+            }
+            json(res, { tagged, skipped, errors });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
+    // POST /api/ai/tag-batch — AI-tag specific assets by ID, concurrently
+    if (pathname === '/api/ai/tag-batch' && req.method === 'POST') {
+        if (!projectConfig) {
+            json(res, { error: 'No project open' }, 400);
+            return;
+        }
+        const apiKey = projectConfig.config.ai?.geminiApiKey;
+        if (!apiKey) {
+            json(res, { error: 'Gemini API key not configured' }, 400);
+            return;
+        }
+        try {
+            const body = JSON.parse(await readBody(req));
+            const ids = body.ids;
+            if (!Array.isArray(ids) || ids.length === 0) {
+                json(res, { error: 'ids must be a non-empty array' }, 400);
+                return;
+            }
+            const { tagAsset: aiTagAsset } = await import('./ai-tagger.js');
+            const { readManifest, readThumbnailFile } = await import('./app/thumbnail-cache.js');
+            const manifest = await readManifest(projectConfig.srcArtDir);
+            const eligible = assets.filter(a => ids.includes(a.id) &&
+                a.status === 'ready' &&
+                !a.settings.excluded &&
+                (!a.settings.tags || a.settings.tags.length === 0) &&
+                a.type !== AssetType.MaterialSchema &&
+                !a.parentId);
+            let tagged = 0;
+            let skipped = ids.length - eligible.length;
+            const errors = [];
+            const CONCURRENCY = 20;
+            // Process in batches of CONCURRENCY
+            for (let i = 0; i < eligible.length; i += CONCURRENCY) {
+                const batch = eligible.slice(i, i + CONCURRENCY);
+                const results = await Promise.allSettled(batch.map(async (asset) => {
+                    let inputData;
+                    let mimeType;
+                    if (asset.type === AssetType.Audio) {
+                        const ext = asset.fileName.split('.').pop()?.toLowerCase() ?? 'wav';
+                        const mimeMap = {
+                            wav: 'audio/wav', mp3: 'audio/mpeg', ogg: 'audio/ogg',
+                            flac: 'audio/flac', aac: 'audio/aac', m4a: 'audio/mp4',
+                        };
+                        mimeType = mimeMap[ext] ?? 'audio/wav';
+                        const raw = await readFile(projectConfig.srcArtDir, asset.id);
+                        if (!raw)
+                            throw new Error('Source file not found');
+                        inputData = Buffer.from(raw);
+                    }
+                    else {
+                        const entry = manifest[asset.stringId];
+                        if (!entry)
+                            throw new Error('No thumbnail cached');
+                        const thumbData = await readThumbnailFile(projectConfig.srcArtDir, asset.stringId, entry.format);
+                        if (!thumbData)
+                            throw new Error('Thumbnail file missing');
+                        inputData = thumbData;
+                        const formatMime = {
+                            png: 'image/png', webp: 'image/webp', webm: 'video/webm',
+                        };
+                        mimeType = formatMime[entry.format] ?? 'image/webp';
+                    }
+                    const newTags = await Promise.race([
+                        aiTagAsset(apiKey, asset.type, asset.fileName, inputData, mimeType),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error('Gemini request timed out (30s)')), 30_000)),
+                    ]);
+                    asset.settings = { ...asset.settings, tags: newTags };
+                    if (!asset.parentId) {
+                        const meta = assetSettingsToStowmeta(asset);
+                        await writeStowmeta(projectConfig.srcArtDir, asset.id, meta);
+                    }
+                    broadcast({ type: 'asset-update', id: asset.id, updates: { settings: asset.settings } });
+                    return asset.id;
+                }));
+                for (const r of results) {
+                    if (r.status === 'fulfilled')
+                        tagged++;
+                    else
+                        errors.push({ id: 'unknown', error: r.reason?.message ?? String(r.reason) });
+                }
+            }
+            json(res, { tagged, skipped, errors });
+        }
+        catch (err) {
+            json(res, { error: err.message }, 500);
+        }
+        return;
+    }
     // GET /api/thumbnails/cached — return which thumbnails are still valid in the cache
     if (pathname === '/api/thumbnails/cached' && req.method === 'GET') {
         if (!projectConfig) {

package/dist/store.d.ts

@@ -35,17 +35,3 @@ export declare function resolveAssetDeps(firestore: FirestoreReader, packageName
     resolvedIds: string[];
     files: string[];
 }>;
-export declare function storeSearch(query: string, opts?: {
-    type?: string;
-    json?: boolean;
-    bucket?: string;
-    limit?: number;
-}): Promise<void>;
-export declare function storeList(opts?: {
-    json?: boolean;
-    bucket?: string;
-}): Promise<void>;
-export declare function storeInfo(packageName: string, opts?: {
-    json?: boolean;
-    bucket?: string;
-}): Promise<void>;

package/dist/store.js

@@ -1,6 +1,4 @@
 import { resolveTransitiveDeps, resolveFiles } from './assets-package.js';
-import { createFirestoreReader } from './firestore.js';
-const DEFAULT_BUCKET = 'rungame-shared-assets-test';
 // ─── Search ──────────────────────────────────────────────────────────────────
 export async function searchAssets(firestore, bucket, query, opts) {
     // Support comma-separated terms: "coral, sea, ocean" matches any term
@@ -13,9 +11,12 @@ export async function searchAssets(firestore, bucket, query, opts) {
     if (opts?.package) {
         packages = packages.filter(p => p.name === opts.package);
     }
-    for (const { name: pkgName, data: pkg } of packages) {
+    // Fetch all latest versions in parallel
+    const versions = await Promise.all(packages.map(({ name, data: pkg }) => firestore.getVersion(name, pkg.latest)));
+    for (let i = 0; i < packages.length; i++) {
+        const { name: pkgName, data: pkg } = packages[i];
         const verStr = pkg.latest;
-        const ver = await firestore.getVersion(pkgName, verStr);
+        const ver = versions[i];
         if (!ver)
             continue;
         for (const asset of ver.assets) {
@@ -178,14 +179,18 @@ function scoreAsset(terms, asset, pkg, pkgName, skipPkgMeta = false) {
 // ─── List Packages ───────────────────────────────────────────────────────────
 export async function listStorePackages(firestore, bucket) {
     const packages = await firestore.listPackages();
-    const results = [];
-    for (const { name, data: pkg } of packages) {
-        const ver = await firestore.getVersion(name, pkg.latest);
-        const versionKeys = await firestore.listVersionKeys(name);
+    // Fetch versions and version keys in parallel for all packages
+    const [versions, versionKeysList] = await Promise.all([
+        Promise.all(packages.map(({ name, data: pkg }) => firestore.getVersion(name, pkg.latest))),
+        Promise.all(packages.map(({ name }) => firestore.listVersionKeys(name))),
+    ]);
+    return packages.map(({ name, data: pkg }, i) => {
+        const ver = versions[i];
+        const versionKeys = versionKeysList[i];
         const thumbnailUrl = pkg.thumbnail
             ? `https://storage.googleapis.com/${bucket}/packages/${name}/${pkg.latest}/${pkg.thumbnail}`
             : undefined;
-        results.push({
+        return {
             name,
             description: pkg.description,
             author: pkg.author,
@@ -195,9 +200,8 @@ export async function listStorePackages(firestore, bucket) {
             assetCount: ver?.assets.length ?? 0,
             totalSize: ver?.totalSize ?? 0,
             thumbnailUrl,
-        });
-    }
-    return results;
+        };
+    });
 }
 // ─── Resolve Dependencies ────────────────────────────────────────────────────
 export async function resolveAssetDeps(firestore, packageName, stringIds, version) {
@@ -212,96 +216,3 @@ export async function resolveAssetDeps(firestore, packageName, stringIds, versio
     const files = resolveFiles(resolvedIds, ver.assets);
     return { resolvedIds, files };
 }
-// ─── CLI Commands ────────────────────────────────────────────────────────────
-export async function storeSearch(query, opts) {
-    const bucket = (opts?.bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
-    const firestore = createFirestoreReader();
-    let results = await searchAssets(firestore, bucket, query, { type: opts?.type });
-    if (opts?.limit && opts.limit > 0)
-        results = results.slice(0, opts.limit);
-    if (opts?.json) {
-        console.log(JSON.stringify(results, null, 2));
-        return;
-    }
-    if (results.length === 0) {
-        console.log(`No assets found matching "${query}"`);
-        return;
-    }
-    console.log(`\nFound ${results.length} asset${results.length !== 1 ? 's' : ''} matching "${query}":\n`);
-    for (const r of results) {
-        const tags = r.tags.length > 0 ? ` [${r.tags.join(', ')}]` : '';
-        const deps = r.dependencies.length > 0 ? ` → ${r.dependencies.join(', ')}` : '';
-        const thumb = r.thumbnail ? ' (has thumbnail)' : '';
-        console.log(`  [${r.type}] ${r.stringId} — ${r.packageName}@${r.version}${tags}${deps}${thumb}`);
-        console.log(`    ${r.file} (${formatBytes(r.size)})`);
-    }
-    console.log('');
-}
-export async function storeList(opts) {
-    const bucket = (opts?.bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
-    const firestore = createFirestoreReader();
-    const packages = await listStorePackages(firestore, bucket);
-    if (opts?.json) {
-        console.log(JSON.stringify(packages, null, 2));
-        return;
-    }
-    if (packages.length === 0) {
-        console.log('No packages published yet.');
-        return;
-    }
-    console.log(`\n${packages.length} package${packages.length !== 1 ? 's' : ''} in the asset store:\n`);
-    for (const p of packages) {
-        const tags = p.tags.length > 0 ? ` [${p.tags.join(', ')}]` : '';
-        const desc = p.description ? ` — ${p.description}` : '';
-        console.log(`  ${p.name}@${p.latest}${desc}${tags}`);
-        console.log(`    ${p.assetCount} assets, ${formatBytes(p.totalSize)}, ${p.versions.length} version${p.versions.length !== 1 ? 's' : ''}`);
-    }
-    console.log('');
-}
-export async function storeInfo(packageName, opts) {
-    const bucket = (opts?.bucket ?? DEFAULT_BUCKET).replace(/^gs:\/\//, '').replace(/\/$/, '');
-    const firestore = createFirestoreReader();
-    const pkg = await firestore.getPackage(packageName);
-    if (!pkg) {
-        console.error(`Package "${packageName}" not found.`);
-        process.exit(1);
-    }
-    const ver = await firestore.getVersion(packageName, pkg.latest);
-    const versionKeys = await firestore.listVersionKeys(packageName);
-    if (opts?.json) {
-        console.log(JSON.stringify({
-            name: packageName,
-            description: pkg.description,
-            author: pkg.author,
-            tags: pkg.tags ?? [],
-            latest: pkg.latest,
-            versions: versionKeys,
-            assets: ver?.assets ?? [],
-        }, null, 2));
-        return;
-    }
-    console.log(`\n${packageName}@${pkg.latest}`);
-    if (pkg.description)
-        console.log(`  ${pkg.description}`);
-    if (pkg.author)
-        console.log(`  Author: ${pkg.author}`);
-    if (pkg.tags?.length)
-        console.log(`  Tags: ${pkg.tags.join(', ')}`);
-    console.log(`  Versions: ${versionKeys.join(', ')}`);
-    if (ver) {
-        console.log(`\nAssets (${ver.assets.length}):\n`);
-        for (const a of ver.assets) {
-            const tags = a.tags.length > 0 ? ` [${a.tags.join(', ')}]` : '';
-            const deps = a.dependencies.length > 0 ? ` → ${a.dependencies.join(', ')}` : '';
-            console.log(`  [${a.type}] ${a.stringId}${tags}${deps} (${formatBytes(a.size)})`);
-        }
-    }
-    console.log('');
-}
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.6.35",
+  "version": "0.6.37",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"
@@ -18,11 +18,12 @@
     "dev": "tsc --watch"
   },
   "dependencies": {
-    "@series-inc/stowkit-packer-gui": "^0.1.22",
+    "@google/genai": "^1.46.0",
     "@series-inc/stowkit-editor": "^0.1.8",
+    "@series-inc/stowkit-packer-gui": "^0.1.24",
+    "@strangeape/ffmpeg-audio-wasm": "^0.1.0",
     "draco3d": "^1.5.7",
     "fbx-parser": "^2.1.3",
-    "@strangeape/ffmpeg-audio-wasm": "^0.1.0",
     "sharp": "^0.33.5",
     "three": "^0.182.0",
     "ws": "^8.18.0"