@magicpixelart/cli 0.5.10 → 0.5.12

package/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.5.12] — 2026-08-26
+
+### Fixed
+
+- **Watch counting no longer looks hung.** Sprite counting used to stay on
+  `Counting sprites in your game…` with no numbers until the first PNG, which
+  on a large Unity tree can take a long time. The spinner now updates as
+  folders are visited (`0 sprites · 128 folders`) and walks `Assets/` before
+  sibling project folders so the sprite count appears sooner.
+
+## [0.5.11] — 2026-08-26
+
+### Changed
+
+- **Sprite counting shows a running total** (`Counting sprites in your
+  game…  1,247`) while walking the project, and watch reuses that first
+  scan so startup does not walk the tree twice.
+
 ## [0.5.10] — 2026-08-26
 
 ### Changed

package/dist/commands/connect.js

@@ -1,8 +1,9 @@
 import kleur from 'kleur';
+import ora from 'ora';
 import { loadConfig, saveConfig } from '../config.js';
 import { assertSafeGlob } from '../util/security.js';
 import { detectProjectKind, isEngineKind } from '../util/framework.js';
-import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage } from '../util/gameScan.js';
+import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage, countingSpritesText } from '../util/gameScan.js';
 import { cmd } from '../util/invoke.js';
 import { runPush } from './push.js';
 /**
@@ -26,7 +27,11 @@ export async function connectCommand(glob) {
         console.log(kleur.yellow('  This folder is not a Unity/Godot/GameMaker project — nothing to ingest from disk.'));
         return;
     }
-    const index = await indexGamePngs(kind, process.cwd(), config.outDir);
+    const spinner = ora({ text: countingSpritesText(0), spinner: 'dots' }).start();
+    const index = await indexGamePngs(kind, process.cwd(), config.outDir, {
+        onProgress: (p) => { spinner.text = countingSpritesText(p); },
+    });
+    spinner.stop();
     if (index.capped) {
         console.log(kleur.yellow(`! ${GAME_INDEX_CAP_HINT}`));
     }

package/dist/commands/push.js

@@ -19,7 +19,7 @@ import { assetDiskPathFromKey, walkOutDirPngs } from '../util/paths.js';
 import { applyDiskFingerprints, indexSyncedBySourceRel, planPush, resolveSyncedKey } from '../util/pushPlan.js';
 import { cmd } from '../util/invoke.js';
 import { detectProjectKind, isEngineKind } from '../util/framework.js';
-import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage } from '../util/gameScan.js';
+import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage, countingSpritesText } from '../util/gameScan.js';
 import { collectSourceRelMap, remapAbsToCloudKeys } from '../util/syncPath.js';
 import { assertSafeIoPath } from '../util/security.js';
 /** Parallel hashing / path checks — enough to saturate disk, low enough to stay polite. */
@@ -42,11 +42,13 @@ export async function runPush(opts = {}) {
 export async function runPushWith(config, state, opts = {}) {
     const quiet = opts.quiet === true;
     const empty = { created: 0, updated: 0, unchanged: 0, conflict: 0, error: 0, imported: 0 };
-    const spinner = quiet ? null : ora('Scanning local sprites…').start();
+    const spinner = quiet ? null : ora(countingSpritesText(0)).start();
     const kind = await detectProjectKind();
     const index = opts.gameIndex
         ?? (isEngineKind(kind)
-            ? await indexGamePngs(kind, process.cwd(), config.outDir)
+            ? await indexGamePngs(kind, process.cwd(), config.outDir, {
+                onProgress: spinner ? (p) => { spinner.text = countingSpritesText(p); } : undefined,
+            })
             : { files: [], capped: false });
     const matched = matchConnectGlobs(index, config.connect ?? []);
     const sourceByKey = collectSourceRelMap(matched.entries, state.synced);

package/dist/commands/search.js

@@ -1,7 +1,8 @@
 import kleur from 'kleur';
+import ora from 'ora';
 import { loadConfig } from '../config.js';
 import { detectProjectKind, isEngineKind } from '../util/framework.js';
-import { indexGamePngs, searchGameIndex, GAME_INDEX_CAP_HINT } from '../util/gameScan.js';
+import { indexGamePngs, searchGameIndex, GAME_INDEX_CAP_HINT, countingSpritesText } from '../util/gameScan.js';
 import { cmd } from '../util/invoke.js';
 const PRINT_CAP = 50;
 /**
@@ -25,7 +26,11 @@ export async function searchCommand(query) {
     catch {
         // Config is optional for search — skip MagicPixel outDir when missing.
     }
-    const index = await indexGamePngs(kind, process.cwd(), outDir);
+    const spinner = ora({ text: countingSpritesText(0), spinner: 'dots' }).start();
+    const index = await indexGamePngs(kind, process.cwd(), outDir, {
+        onProgress: (p) => { spinner.text = countingSpritesText(p); },
+    });
+    spinner.stop();
     if (index.capped) {
         console.log(kleur.yellow(`! ${GAME_INDEX_CAP_HINT}`));
     }

package/dist/commands/sync.js

@@ -12,7 +12,7 @@ import { createLimit } from '../util/limit.js';
 import { emitTypedIndex, ensureAgentsDoc, scanDiskAssets } from '../util/emitIndex.js';
 import { assertPathInsideRoot, assertSafeIoPath } from '../util/security.js';
 import { detectProjectKind, isEngineKind } from '../util/framework.js';
-import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage } from '../util/gameScan.js';
+import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage, countingSpritesText } from '../util/gameScan.js';
 import { collectSourceRelMap, isPathInside, syncDiskPathFromKey } from '../util/syncPath.js';
 import { DEFAULT_UNITY_PPU, writeMissingUnityMetas } from '../util/unityMeta.js';
 import { filterUnityManifest } from '../util/unityFilter.js';
@@ -61,22 +61,22 @@ async function watchLoop(opts) {
             const config = await loadConfig();
             const kind = await detectProjectKind();
             if (isEngineKind(kind) && (config.connect?.length ?? 0) > 0) {
-                countSpinner = ora({ text: 'Counting sprites in your game…', spinner: 'dots' }).start();
+                countSpinner = ora({ text: countingSpritesText(0), spinner: 'dots' }).start();
             }
         }
         catch {
             /* header is cosmetic */
         }
     }
-    const spriteLine = await loadWatchSpriteLine();
+    const header = await loadWatchHeader(countSpinner ? (p) => { countSpinner.text = countingSpritesText(p); } : undefined);
     if (countSpinner) {
-        if (spriteLine)
-            countSpinner.succeed(spriteLine.trim());
+        if (header.line)
+            countSpinner.succeed(header.line.trim());
         else
             countSpinner.stop();
     }
-    else if (spriteLine && !opts.quiet) {
-        console.log(kleur.dim(spriteLine));
+    else if (header.line && !opts.quiet) {
+        console.log(kleur.dim(header.line));
     }
     console.log(kleur.dim(`   Polling:  every ${intervalSec}s (slows when idle)   ·   Stop: Ctrl+C`));
     console.log();
@@ -143,7 +143,7 @@ async function watchLoop(opts) {
         };
         try {
             onStatus('Checking MagicPixel…');
-            const r = await runOnce({ ...opts, watch: false }, { watchMode: true, onStatus });
+            const r = await runOnce({ ...opts, watch: false }, { watchMode: true, onStatus, gameIndex: header.gameIndex });
             // Reset backoff on any successful tick. Resume message fires once when
             // we recover from an auth pause — `getApiKey()` re-reads
             // .magicpixel/credentials on every call, so a `magicpixel login` in
@@ -242,6 +242,7 @@ async function watchLoop(opts) {
             }
         }
         finally {
+            header.gameIndex = undefined;
             inFlight = false;
         }
     };
@@ -329,25 +330,25 @@ export function classifyTickError(err, state) {
     }
     return { kind: 'other', nextBackoffSec: Math.min(state.backoffSec * 2, 60) };
 }
-async function loadWatchSpriteLine() {
+async function loadWatchHeader(onProgress) {
     try {
         const config = await loadConfig();
         const state = await loadState();
         const lastPulled = state.assets ? Object.keys(state.assets).length : 0;
         let workingSet = 0;
+        let gameIndex;
         const kind = await detectProjectKind();
         if (isEngineKind(kind) && (config.connect?.length ?? 0) > 0) {
-            const index = await indexGamePngs(kind, process.cwd(), config.outDir);
-            const matched = matchConnectGlobs(index, config.connect);
-            workingSet = matched.total;
+            gameIndex = await indexGamePngs(kind, process.cwd(), config.outDir, { onProgress });
+            workingSet = matchConnectGlobs(gameIndex, config.connect).total;
         }
         else if (state.synced) {
             workingSet = Object.keys(state.synced).length;
         }
-        return formatWatchSpriteLine({ workingSet, lastPulled });
+        return { line: formatWatchSpriteLine({ workingSet, lastPulled }), gameIndex };
     }
     catch {
-        return null;
+        return { line: null };
     }
 }
 async function runOnce(opts, runOpts = {}) {
@@ -406,9 +407,18 @@ async function runOnce(opts, runOpts = {}) {
     // magicpixel.json opts back into everything.
     onStatus?.('Looking through your game sprites…');
     const projectKind = await detectProjectKind();
-    const gameIndex = isEngineKind(projectKind)
-        ? await indexGamePngs(projectKind, process.cwd(), config.outDir)
-        : { files: [], capped: false };
+    const gameIndex = runOpts.gameIndex
+        ?? (isEngineKind(projectKind)
+            ? await indexGamePngs(projectKind, process.cwd(), config.outDir, {
+                onProgress: (p) => {
+                    const n = p.pngs.toLocaleString('en-US');
+                    const f = p.folders.toLocaleString('en-US');
+                    onStatus?.(p.folders > 0
+                        ? `Looking through your game sprites…  ${n} sprites · ${f} folders`
+                        : `Looking through your game sprites…  ${n}`);
+                },
+            })
+            : { files: [], capped: false });
     const connected = matchConnectGlobs(gameIndex, config.connect ?? []);
     const sourceByKey = collectSourceRelMap(connected.entries, state.synced);
     if (verbose && gameIndex.capped) {

package/dist/util/gameScan.js

@@ -23,6 +23,10 @@ export const GAME_SCAN_SKIP_DIRS = new Set([
     'streamingassets',
     'node_modules',
     'magicpixel',
+    'build',
+    'builds',
+    'recordings',
+    'memorycaptures',
 ]);
 /**
  * Dot-directories we never walk. Other hidden folders (e.g. `.SpineRaw_*`)
@@ -94,8 +98,43 @@ function toEntry(abs, cwdAbs, assetRoot) {
         return null;
     return { abs, sourceRel, adoptRel, key: adopted.path.join('/') };
 }
+function fmtCount(n, noun) {
+    return `${n.toLocaleString('en-US')} ${noun}${n === 1 ? '' : 's'}`;
+}
+/** Spinner / status copy while walking the game tree. */
+export function countingSpritesText(progress = 0) {
+    const pngs = typeof progress === 'number' ? progress : progress.pngs;
+    const folders = typeof progress === 'number' ? 0 : progress.folders;
+    if (pngs === 0 && folders === 0)
+        return 'Counting sprites in your game…';
+    const spriteBit = fmtCount(pngs, 'sprite');
+    if (folders > 0)
+        return `Counting sprites in your game…  ${spriteBit} · ${fmtCount(folders, 'folder')}`;
+    return `Counting sprites in your game…  ${spriteBit}`;
+}
+function bindScanProgress(onProgress) {
+    if (!onProgress)
+        return () => { };
+    let lastAt = 0;
+    let lastPngs = -1;
+    let lastFolders = -1;
+    return (pngs, folders) => {
+        if (pngs === lastPngs && folders === lastFolders)
+            return;
+        const now = Date.now();
+        if (lastPngs < 0 || now - lastAt >= 80) {
+            lastAt = now;
+            lastPngs = pngs;
+            lastFolders = folders;
+            onProgress({ pngs, folders });
+        }
+    };
+}
+function samePath(a, b) {
+    return a.replace(/\\/g, '/').toLowerCase() === b.replace(/\\/g, '/').toLowerCase();
+}
 /** Walk the engine tree and return index entries. Does not copy files. */
-export async function indexGamePngs(kind, cwd = process.cwd(), outDir = '') {
+export async function indexGamePngs(kind, cwd = process.cwd(), outDir = '', opts = {}) {
     const empty = { files: [], capped: false };
     if (!isEngineKind(kind))
         return empty;
@@ -106,8 +145,11 @@ export async function indexGamePngs(kind, cwd = process.cwd(), outDir = '') {
     const namedRoot = gameScanRoot(kind);
     const assetRoot = namedRoot ? resolveChildDir(cwd, namedRoot) : null;
     const found = [];
+    const stats = { folders: 0 };
     const io = createLimit(SCAN_WALK_CONCURRENCY);
-    await walkPngs(scanRoot, scanRoot, destNorm, found, MAX_GAME_INDEX + 1, io);
+    const report = bindScanProgress(opts.onProgress);
+    await walkPngs(scanRoot, scanRoot, destNorm, found, MAX_GAME_INDEX + 1, io, report, stats, assetRoot);
+    opts.onProgress?.({ pngs: found.length, folders: stats.folders });
     found.sort((a, b) => a.localeCompare(b));
     const capped = found.length > MAX_GAME_INDEX;
     if (capped)
@@ -136,9 +178,12 @@ export function searchGameIndex(index, query) {
         return [];
     return index.files.filter((e) => e.sourceRel.toLowerCase().includes(q) || e.key.includes(q) || e.adoptRel.toLowerCase().includes(q));
 }
-async function walkPngs(dir, root, destNorm, out, limit, io) {
+async function walkPngs(dir, root, destNorm, out, limit, io, onVisit, stats, preferFirst) {
     if (out.length >= limit)
         return;
+    // Count the folder *before* readdir so a huge listing still shows movement.
+    stats.folders++;
+    onVisit(out.length, stats.folders);
     let entries;
     try {
         entries = await readdir(dir, { withFileTypes: true });
@@ -147,7 +192,8 @@ async function walkPngs(dir, root, destNorm, out, limit, io) {
         return;
     }
     entries.sort((a, b) => a.name.localeCompare(b.name));
-    const subdirs = [];
+    const preferred = [];
+    const other = [];
     for (const ent of entries) {
         if (out.length >= limit)
             return;
@@ -165,13 +211,25 @@ async function walkPngs(dir, root, destNorm, out, limit, io) {
                 continue;
             if (destNorm && full.replace(/\\/g, '/').toLowerCase() === destNorm)
                 continue;
-            subdirs.push(full);
+            if (preferFirst && samePath(full, preferFirst))
+                preferred.push(full);
+            else
+                other.push(full);
         }
         else if (ent.isFile() && ent.name.toLowerCase().endsWith('.png')) {
             out.push(full);
+            onVisit(out.length, stats.folders);
         }
     }
-    if (subdirs.length === 0 || out.length >= limit)
+    if (out.length >= limit)
+        return;
+    // Engine asset tree first (Unity `Assets/`) so sprite counts appear before
+    // sibling folders like Builds/Editor. Nested walks keep preferFirst so a
+    // misplaced `Assets` dir is still prioritized if we ever see it.
+    for (const d of preferred) {
+        await walkPngs(d, root, destNorm, out, limit, io, onVisit, stats, null);
+    }
+    if (other.length === 0 || out.length >= limit)
         return;
-    await Promise.all(subdirs.map((d) => io(() => walkPngs(d, root, destNorm, out, limit, io))));
+    await Promise.all(other.map((d) => io(() => walkPngs(d, root, destNorm, out, limit, io, onVisit, stats, null))));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magicpixelart/cli",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "Sync MagicPixel pixel-art assets to your local project.",
   "type": "module",
   "bin": {