Make wizard smart detect deterministic

Author: alexphillips-dev

archive/folderview.plus-2026.03.21.12.txz.sha256

@@ -0,0 +1 @@
+9ac8c53bdcd9f271457c353762d57538750c53b3da082a2b0e9a679c9d3b6e5f  folderview.plus-2026.03.21.41.txz

archive/folderview.plus-2026.03.21.12.txz archive/folderview.plus-2026.03.21.41.txzarchive/folderview.plus-2026.03.21.12.txz renamed to archive/folderview.plus-2026.03.21.41.txz

@@ -6,13 +6,19 @@
 <!ENTITY launch "Settings/FolderViewPlus">
 <!ENTITY plugdir "/usr/local/emhttp/plugins/&name;">
 <!ENTITY pluginURL "https://raw.githubusercontent.com/&github;/dev/folderview.plus.plg">
-<!ENTITY version "2026.03.21.40">
-<!ENTITY md5 "2d30f6054962dcf9c49c8c5e777e5608">
+<!ENTITY version "2026.03.21.41">
+<!ENTITY md5 "f7495fd47195a61f75848f0360a72f29">
 ]>
 
 <PLUGIN name="&name;" author="&author;" version="&version;" launch="&launch;" pluginURL="&pluginURL;" icon="folder-icon.png" support="https://forums.unraid.net/topic/197631-plugin-folderview-plus/" min="7.0.0">
     <CHANGES>
 
+###2026.03.21.41
+- Fix: Smart template creation in the setup wizard now derives folders from per-item best matches instead of weaker aggregate workload guesses.
+- Fix: Improved starter-folder auto-assignment reliability so mixed app stacks create and use the folders they actually need.
+- Regression guard: Added wizard coverage to ensure smart selection stays aligned with real container-to-folder matches.
+
+
 ###2026.03.21.40
 - Fix: Expanded smart-detect coverage for Docker starter folders so more real-world app families are recognized and auto-assigned during wizard onboarding.
 - Quality: Smart category selection now uses richer runtime signals, including compose stacks, template metadata, bind paths, project/support URLs, and broader fuzzy token matching.

archive/folderview.plus-2026.03.21.41.txz.sha256

@@ -603,7 +603,7 @@ const getSetupAssistantTemplateCategoryState = (type) => {
         categoryIndexBuckets.get(normalized).add(index);
     };
 
-    const smartIndexes = resolveStarterTemplateSmartIndexes(resolvedType, blueprints);
+    const smartIndexes = resolveSetupAssistantSmartBlueprintIndexes(resolvedType, blueprints).indexes;
     smartIndexes.forEach((index) => addCategoryIndex('smart', index));
     blueprints.forEach((entry, index) => {
         const categories = Array.isArray(entry?.categories) ? entry.categories : [];
@@ -691,37 +691,7 @@ const SETUP_ASSISTANT_TEMPLATE_FALLBACK_BY_TYPE = Object.freeze({
     docker: 'Utilities',
     vm: 'Utility VMs'
 });
-
-const getSetupAssistantBlueprintHeuristicMap = (type, blueprintName) => {
-    const resolvedType = normalizeManagedType(type);
-    const normalizedName = normalizeSetupAssistantMatchText(blueprintName).replace(/\s+/g, '-');
-    if (resolvedType === 'docker') {
-        const dockerMap = {
-            media: { contains: ['seerr', 'wizarr', 'listenarr', 'cleanuparr', 'agregarr', 'watch', 'request', 'discover'], pathContains: ['media', 'movies', 'shows', 'tv', 'music', 'books', 'audiobooks', 'anime', 'comics', 'photos'] },
-            downloads: { contains: ['download', 'torrent', 'nzb', 'slsk', 'seed'] },
-            monitoring: { contains: ['myspeed', 'speedtest', 'latency', 'uptime', 'metrics', 'telemetry'] },
-            'cloud-&-sync': { contains: ['nextcloud', 'owncloud', 'seafile', 'cloud', 'sync', 'drive', 'collabora', 'onlyoffice'] },
-            notifications: { contains: ['notify', 'notification', 'ntfy', 'gotify', 'apprise', 'notifiarr', 'pushover', 'webhook'] },
-            utilities: { contains: ['qdirstat', 'diskspeed', 'ncdu', 'baobab', 'icons', 'icon', 'tool', 'utility', 'manager'], pathContains: ['appdata', 'storage', 'tools'] },
-            automation: { contains: ['homeassistant', 'node red', 'n8n', 'mqtt', 'esphome', 'zigbee', 'zwave'] },
-            database: { contains: ['postgres', 'mysql', 'mariadb', 'mongo', 'redis', 'database', 'db'] },
-            security: { contains: ['clamav', 'antivirus', 'vaultwarden', 'authentik', 'authelia', 'crowdsec', 'fail2ban', 'security'] },
-            development: { contains: ['git', 'code', 'dev', 'build', 'registry', 'runner', 'vscode'] },
-            'ci-cd': { contains: ['jenkins', 'runner', 'drone', 'argocd', 'ci', 'cd'] },
-            gaming: { contains: ['crafty', 'minecraft', 'palworld', 'valheim', 'satisfactory', 'steam', 'gameserver', 'server'] },
-            'game-servers': { contains: ['crafty', 'pterodactyl', 'pelican', 'steamcmd', 'minecraft', 'palworld', 'valheim', 'satisfactory', 'terraria', 'enshrouded', 'gameserver', 'server'] }
-        };
-        return dockerMap[normalizedName] || null;
-    }
-    const vmMap = {
-        'utility-vms': { contains: ['utility', 'tools', 'helper', 'management', 'admin'] },
-        'network-vms': { contains: ['router', 'firewall', 'pfsense', 'opnsense', 'dns', 'proxy'] },
-        'security-vms': { contains: ['security', 'siem', 'wazuh', 'ids', 'ips', 'firewall'] },
-        'desktop-vms': { contains: ['desktop', 'workstation', 'windows', 'ubuntu', 'macos'] },
-        'gaming-vms': { contains: ['gaming', 'steam', 'parsec', 'moonlight', 'sunshine', 'gpu'] }
-    };
-    return vmMap[normalizedName] || null;
-};
+const SETUP_ASSISTANT_TEMPLATE_MATCH_THRESHOLD = 4;
 
 const collectSetupAssistantItemMatchProfile = (type, itemName, itemInfo) => {
     const resolvedType = normalizeManagedType(type);
@@ -863,21 +833,103 @@ const scoreSetupAssistantTemplateMatch = (profile, blueprint, type = 'docker') =
         }
         return false;
     };
+    const getHeuristicBoost = () => {
+        const normalizedName = normalizeSetupAssistantMatchText(blueprint?.name).replace(/\s+/g, '-');
+        if (type !== 'docker') {
+            return 0;
+        }
+        if (normalizedName === 'media') {
+            let next = 0;
+            if (hasTokenEndingWith('arr')) {
+                next += 12;
+            }
+            if (hasTokenContainingAny(['seerr', 'wizarr', 'listenarr', 'cleanuparr', 'agregarr', 'watch', 'request', 'discover'])) {
+                next += 10;
+            }
+            if (hasTokenContainingAny(['media', 'movies', 'shows', 'tv', 'music', 'books', 'audiobooks', 'anime', 'comics', 'photos'])) {
+                next += 6;
+            }
+            return next;
+        }
+        if (normalizedName === 'game-servers' || normalizedName === 'gaming') {
+            return hasTokenContainingAny(['crafty', 'pterodactyl', 'pelican', 'satisfactory', 'minecraft', 'palworld', 'valheim', 'steamcmd', 'gameserver', 'server']) ? 10 : 0;
+        }
+        if (normalizedName === 'monitoring') {
+            return hasTokenContainingAny(['myspeed', 'speedtest', 'latency', 'uptime', 'metrics']) ? 10 : 0;
+        }
+        if (normalizedName === 'cloud-&-sync') {
+            return hasTokenContainingAny(['nextcloud', 'owncloud', 'seafile', 'cloud', 'sync', 'drive', 'collabora', 'onlyoffice']) ? 10 : 0;
+        }
+        if (normalizedName === 'notifications') {
+            return hasTokenContainingAny(['notify', 'notification', 'ntfy', 'gotify', 'apprise', 'notifiarr', 'pushover', 'webhook']) ? 10 : 0;
+        }
+        if (normalizedName === 'utilities') {
+            let next = hasTokenContainingAny(['qdirstat', 'diskspeed', 'icons', 'icon', 'tool', 'utility', 'manager']) ? 10 : 0;
+            if (hasTokenContainingAny(['appdata', 'storage', 'tools'])) {
+                next += 6;
+            }
+            return next;
+        }
+        if (normalizedName === 'security') {
+            return hasTokenContainingAny(['clamav', 'antivirus', 'vaultwarden', 'authentik', 'authelia', 'crowdsec', 'fail2ban', 'security']) ? 10 : 0;
+        }
+        return 0;
+    };
     detectKeywords.forEach((keyword) => consumeKeyword(keyword, 1));
     consumeKeyword(blueprint.name, 0.6);
-    const heuristic = getSetupAssistantBlueprintHeuristicMap(type, blueprint?.name || '');
-    if (heuristic) {
-        if (normalizeSetupAssistantMatchText(blueprint?.name).replace(/\s+/g, '-') === 'media' && hasTokenEndingWith('arr')) {
-            score += 12;
+    score += getHeuristicBoost();
+    return score;
+};
+
+const resolveSetupAssistantTemplateBestMatch = (type, profile, blueprints) => {
+    const resolvedType = normalizeManagedType(type);
+    let bestBlueprint = null;
+    let bestScore = 0;
+    let bestIndex = -1;
+    (Array.isArray(blueprints) ? blueprints : []).forEach((blueprint, index) => {
+        const score = scoreSetupAssistantTemplateMatch(profile, blueprint, resolvedType);
+        if (score > bestScore) {
+            bestBlueprint = blueprint;
+            bestScore = score;
+            bestIndex = index;
         }
-        if (hasTokenContainingAny(heuristic.contains)) {
-            score += 10;
+    });
+    return { bestBlueprint, bestScore, bestIndex };
+};
+
+const resolveSetupAssistantSmartBlueprintIndexes = (type, blueprints) => {
+    const resolvedType = normalizeManagedType(type);
+    const safeBlueprints = Array.isArray(blueprints) ? blueprints : [];
+    const itemNames = getBulkAssignableNames(resolvedType);
+    const info = infoByType[resolvedType] || {};
+    const matchedIndexes = new Set();
+    const fallbackTemplateName = String(SETUP_ASSISTANT_TEMPLATE_FALLBACK_BY_TYPE[resolvedType] || '').trim();
+    const fallbackIndex = safeBlueprints.findIndex((blueprint) => String(blueprint?.name || '').trim() === fallbackTemplateName);
+
+    let matched = 0;
+    let unmatched = 0;
+    itemNames.forEach((itemName) => {
+        const profile = collectSetupAssistantItemMatchProfile(resolvedType, itemName, info[itemName] || {});
+        const { bestScore, bestIndex } = resolveSetupAssistantTemplateBestMatch(resolvedType, profile, safeBlueprints);
+        if (bestIndex >= 0 && bestScore >= SETUP_ASSISTANT_TEMPLATE_MATCH_THRESHOLD) {
+            matchedIndexes.add(bestIndex);
+            matched += 1;
+            return;
         }
-        if (hasTokenContainingAny(heuristic.pathContains)) {
-            score += 6;
+        if (fallbackIndex >= 0) {
+            matchedIndexes.add(fallbackIndex);
+            matched += 1;
+            return;
         }
-    }
-    return score;
+        unmatched += 1;
+    });
+
+    return {
+        indexes: matchedIndexes,
+        totalItems: itemNames.length,
+        matched,
+        unmatched
+    };
 };
 
 const buildSetupAssistantTemplateAssignmentPreview = (type, selectedBlueprints) => {
@@ -899,20 +951,12 @@ const buildSetupAssistantTemplateAssignmentPreview = (type, selectedBlueprints)
     let unmatched = 0;
     itemNames.forEach((itemName) => {
         const profile = collectSetupAssistantItemMatchProfile(resolvedType, itemName, info[itemName] || {});
-        let bestBlueprint = null;
-        let bestScore = 0;
-        blueprints.forEach((blueprint) => {
-            const score = scoreSetupAssistantTemplateMatch(profile, blueprint, resolvedType);
-            if (score > bestScore) {
-                bestScore = score;
-                bestBlueprint = blueprint;
-            }
-        });
-        if ((!bestBlueprint || bestScore < 4) && fallbackBlueprint) {
+        let { bestBlueprint, bestScore } = resolveSetupAssistantTemplateBestMatch(resolvedType, profile, blueprints);
+        if ((!bestBlueprint || bestScore < SETUP_ASSISTANT_TEMPLATE_MATCH_THRESHOLD) && fallbackBlueprint) {
             bestBlueprint = fallbackBlueprint;
-            bestScore = 4;
+            bestScore = SETUP_ASSISTANT_TEMPLATE_MATCH_THRESHOLD;
         }
-        if (!bestBlueprint || bestScore < 4) {
+        if (!bestBlueprint || bestScore < SETUP_ASSISTANT_TEMPLATE_MATCH_THRESHOLD) {
             unmatched += 1;
             return;
         }

folderview.plus.plg

@@ -73,6 +73,7 @@ const loadSmartDetectHelpers = (infoByType) => {
         '    normalizeSetupAssistantMatchText,',
         '    collectSetupAssistantItemMatchProfile,',
         '    scoreSetupAssistantTemplateMatch,',
+        '    resolveSetupAssistantSmartBlueprintIndexes,',
         '    buildSetupAssistantTemplateAssignmentPreview',
         '};'
     ].join('\n')).runInContext(context);
@@ -271,6 +272,40 @@ test('wizard smart detect covers mixed real-world docker families without misses
     assert.deepEqual(Array.from(preview.assignedByTemplate.Notifications || []), ['Notify']);
 });
 
+test('wizard smart starter selection derives folders from per-item best matches', () => {
+    const infoByType = {
+        docker: {
+            listenarr: { info: { Config: { Image: 'ghcr.io/listenarr/listenarr:latest' } } },
+            ClamAV: { info: { Config: { Image: 'clamav/clamav:latest' } } },
+            'satisfactory-server': { info: { Config: { Image: 'wolveix/satisfactory-server:latest' } } },
+            nextcloud: { info: { Config: { Image: 'nextcloud:latest' } } },
+            Notify: { info: { Config: { Image: 'ghcr.io/notifiarr/notify:latest' } } },
+            QDirStat: { info: { Config: { Image: 'ghcr.io/linuxserver/qdirstat:latest' } } }
+        }
+    };
+    const runtime = loadSmartDetectHelpers(infoByType);
+    const result = runtime.resolveSetupAssistantSmartBlueprintIndexes('docker', [
+        { name: 'Media', detect: ['listenarr', 'seerr', 'wizarr'] },
+        { name: 'Security', detect: ['vaultwarden', 'clamav'] },
+        { name: 'Utilities', detect: ['qdirstat', 'diskspeed', 'vm_custom_icons'] },
+        { name: 'Game Servers', detect: ['crafty', 'satisfactory-server'] },
+        { name: 'Cloud & Sync', detect: ['nextcloud'] },
+        { name: 'Notifications', detect: ['notify', 'notifiarr'] }
+    ]);
+    const names = Array.from(result.indexes)
+        .map((index) => ['Media', 'Security', 'Utilities', 'Game Servers', 'Cloud & Sync', 'Notifications'][index])
+        .filter(Boolean);
+
+    assert.equal(result.totalItems, 6);
+    assert.equal(result.unmatched, 0);
+    assert.ok(names.includes('Media'));
+    assert.ok(names.includes('Security'));
+    assert.ok(names.includes('Utilities'));
+    assert.ok(names.includes('Game Servers'));
+    assert.ok(names.includes('Cloud & Sync'));
+    assert.ok(names.includes('Notifications'));
+});
+
 test('smart starter selection surfaces the needed folders for mixed docker workloads', () => {
     const infoByType = {
         docker: {