@series-inc/stowkit-cli 0.6.36 → 0.6.38

package/dist/ai-tagger.js

@@ -1,6 +1,6 @@
 import { GoogleGenAI } from '@google/genai';
 import { AssetType } from './core/types.js';
-const MODEL = 'gemini-2.5-flash-lite-preview';
+const MODEL = 'gemini-3.1-flash-lite-preview';
 const ASSET_TYPE_LABELS = {
     [AssetType.Texture2D]: 'texture',
     [AssetType.StaticMesh]: '3D mesh',

package/dist/firestore.d.ts

@@ -29,6 +29,7 @@ export interface FirestoreClient extends FirestoreReader {
     deletePackage(name: string): Promise<void>;
     setVersion(packageName: string, version: string, data: FirestoreVersionDoc): Promise<void>;
 }
+export declare function clearFirestoreCache(): void;
 /**
  * Create a read-only Firestore client using the public API key.
  * No service account or credentials needed — safe for CLI store commands,

package/dist/firestore.js

@@ -73,6 +73,9 @@ function objectToFields(data) {
 // ─── In-memory cache ─────────────────────────────────────────────────────────
 const CACHE_TTL_MS = 60_000; // 1 minute
 const cache = new Map();
+export function clearFirestoreCache() {
+    cache.clear();
+}
 function cacheGet(key) {
     const entry = cache.get(key);
     if (!entry)

package/dist/server.js

@@ -1789,6 +1789,10 @@ async function handleRequest(req, res, staticApps) {
     // GET /api/asset-store/registry — fetch the public registry
     if (pathname === '/api/asset-store/registry' && req.method === 'GET') {
         try {
+            if (url.searchParams.get('refresh')) {
+                const { clearFirestoreCache } = await import('./firestore.js');
+                clearFirestoreCache();
+            }
             const { createFirestoreReader } = await import('./firestore.js');
             const reader = createFirestoreReader();
             const allPackages = await reader.listPackages();
@@ -1846,6 +1850,10 @@ async function handleRequest(req, res, staticApps) {
     // GET /api/asset-store/packages — list all packages
     if (pathname === '/api/asset-store/packages' && req.method === 'GET') {
         try {
+            if (url.searchParams.get('refresh')) {
+                const { clearFirestoreCache } = await import('./firestore.js');
+                clearFirestoreCache();
+            }
             const bucketParam = url.searchParams.get('bucket') ?? undefined;
             const { createFirestoreReader } = await import('./firestore.js');
             const { listStorePackages } = await import('./store.js');
@@ -2196,6 +2204,94 @@ async function handleRequest(req, res, staticApps) {
         }
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@series-inc/stowkit-cli",
-  "version": "0.6.36",
+  "version": "0.6.38",
   "type": "module",
   "bin": {
     "stowkit": "./dist/cli.js"
@@ -20,7 +20,7 @@
   "dependencies": {
     "@google/genai": "^1.46.0",
     "@series-inc/stowkit-editor": "^0.1.8",
-    "@series-inc/stowkit-packer-gui": "^0.1.23",
+    "@series-inc/stowkit-packer-gui": "^0.1.25",
     "@strangeape/ffmpeg-audio-wasm": "^0.1.0",
     "draco3d": "^1.5.7",
     "fbx-parser": "^2.1.3",