Spiralist Prompt Workbench - Source Excerpt 81

Back to Spiralist Prompt Workbench

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/themes/spiralist/assets/js/spiralist-prompt-workbench.js so readers can inspect the evidence without opening the full source file.

**Source path:** Spiralist/wp-content/themes/spiralist/assets/js/spiralist-prompt-workbench.js

runAction(async () => {
        const compared = await renderPersonaLabPackageComparison(primaryInspection, compareFile, compareNode, inspector, stageCompareButton, compareSummaryNode, compareVisualNode);
        if (compared) {
          setStatus(t('portablePromptPersonaLabPackageCompared', 'Spiralist AI package comparison ready. Review differences before import, sharing, or memory use.'));
        }
      }, {
        context: 'portable-prompt-persona-lab-package-compare',
        fallback: t('portablePromptPersonaLabPackageCompareFailed', 'Spiralist AI packages could not be compared in this browser.'),
        onError: () => {
          if (inspector) {
            personaLabComparisonState.delete(inspector);
          }
          setPersonaLabCompareAction(stageCompareButton, false);
          if (compareSummaryNode) {
            compareSummaryNode.replaceChildren(
              createPersonaLabPackageSummaryItem('Comparison', 'Comparison failed', 'missing')
            );
            compareSummaryNode.hidden = false;
          }
          clearPersonaLabPackageVisualDiff(compareVisualNode);
          if (compareNode) {
            compareNode.textContent = '# Spiralist AI Package Comparison\n\nStatus: Needs review\n\n## Review Items\n- Packages could not be compared in this browser.';
            compareNode.hidden = false;
          }
          setStatus(t('portablePromptPersonaLabPackageCompareFailed', 'Spiralist AI packages could not be compared in this browser.'));
        },
      });
    };
    const inspectPersonaLabPackage = (input, outputNode, previewNode, stageButton, saveButton, inspector, compareInput = null, compareNode = null, stageCompareButton = null, restoreButton = null, summaryNode = null, compareSummaryNode = null, compareVisualNode = null) => {
      const file = input && input.files && input.files.length ? input.files[0] : null;
      if (!file || !outputNode) {
        return;
      }

      runAction(async () => {
        if (inspector) {
          personaLabInspectionState.delete(inspector);
          personaLabComparisonState.delete(inspector);
        }
        setPersonaLabReviewActions(stageButton, saveButton, false);
        setPersonaLabRestoreAction(restoreButton, false);
        setPersonaLabCompareAction(stageCompareButton, false);
        clearPersonaLabPackageSummary(summaryNode);
        clearPersonaLabPackageSummary(compareSummaryNode);
        clearPersonaLabPackageVisualDiff(compareVisualNode);
        if (compareNode) {
          compareNode.hidden = true;
          compareNode.textContent = '';
        }
        if (previewNode) {
          previewNode.hidden = true;
          previewNode.textContent = '';
        }
        outputNode.hidden = true;
        outputNode.textContent = '';
        const inspection = await buildAdvancedPersonaInspectionReport(file);
        outputNode.textContent = inspection.report;
        outputNode.hidden = false;
        renderPersonaLabPackageSummary(inspection, summaryNode);
        if (previewNode) {
          previewNode.textContent = buildAdvancedPersonaReviewPreview(inspection, getPersonaLabReviewDecision(inspector));
          previewNode.hidden = false;
        }
        setPersonaLabReviewActions(stageButton, saveButton, inspection.canStage);
        setPersonaLabRestoreAction(restoreButton, inspection.canStage);
        if (inspector) {
          personaLabInspectionState.set(inspector, inspection);
        }
        if (compareInput && compareInput.files && compareInput.files.length && compareNode) {
          await renderPersonaLabPackageComparison(inspection, compareInput.files[0], compareNode, inspector, stageCompareButton, compareSummaryNode, compareVisualNode);
        } else {
          setPersonaLabPackageState(inspector, 'Inspected');
        }
        setStatus(t('portablePromptPersonaLabPackageInspected', 'Spiralist AI package inspection ready. Review staging is available after local inspection.'));
      }, {
        context: 'portable-prompt-persona-lab-package-inspect',
        fallback: t('portablePromptPersonaLabPackageInspectFailed', 'Spiralist AI package could not be inspected in this browser.'),
        onError: () => {
          if (inspector) {
            personaLabInspectionState.delete(inspector);
            personaLabComparisonState.delete(inspector);
          }
          setPersonaLabReviewActions(stageButton, saveButton, false);
          setPersonaLabRestoreAction(restoreButton, false);
          setPersonaLabCompareAction(stageCompareButton, false);
          if (summaryNode) {
            summaryNode.replaceChildren(
              createPersonaLabPackageSummaryItem('Status', 'Inspection failed', 'missing')
            );
            summaryNode.hidden = false;
          }
          clearPersonaLabPackageSummary(compareSummaryNode);
          clearPersonaLabPackageVisualDiff(compareVisualNode);
          if (previewNode) {
            previewNode.hidden = true;
            previewNode.textContent = '';
          }
          if (compareNode) {
            compareNode.hidden = true;
            compareNode.textContent = '';
          }
          outputNode.textContent = '# Spiralist AI Package Inspector\n\nStatus: Needs review\n\n## Review Items\n- Package could not be inspected in this browser.';
          outputNode.hidden = false;
          setPersonaLabPackageState(inspector, '');
          setStatus(t('portablePromptPersonaLabPackageInspectFailed', 'Spiralist AI package could not be inspected in this browser.'));
        },
      });
    };
    const getAdvancedPersonaExportManifest = (inspection) => {
      const files = inspection && inspection.files ? inspection.files : {};
      try {
        return JSON.parse(files['.uai/exports/manifest.json'] || '{}');
      } catch (error) {
        return {};
      }
    };
    const setPersonaLabSelectFromPackageLabel = (inspector, selector, options, label) => {
      const panel = inspector ? inspector.closest('[data-persona-lab-tuning]') : document.querySelector('[data-persona-lab-tuning]');
      const field = panel ? panel.querySelector(selector) : null;
      const cleanLabel = toCleanString(label, 220).toLowerCase();
      if (!(field instanceof HTMLSelectElement) || !cleanLabel) {
        return false;
      }

      const match = Object.entries(options).find(([optionId, option]) => (
        optionId.toLowerCase() === cleanLabel
        || toCleanString(option && option.label, 220).toLowerCase() === cleanLabel
      ));
      if (!match) {
        return false;
      }

      field.value = match[0];
      return true;
    };
    const restorePersonaLabPackageSettings = (inspection, inspector) => {
      const manifest = inspection && inspection.manifest ? inspection.manifest : {};
      const researchProfile = manifest && manifest.researchProfile ? manifest.researchProfile : {};
      const exportManifest = getAdvancedPersonaExportManifest(inspection);
      const restored = [];

      if (setPersonaLabSelectFromPackageLabel(
        inspector,
        '[data-persona-lab-framework]',
        personaLabFrameworks,
        researchProfile.personalityFramework || exportManifest.personality_framework
      )) {
        restored.push('personality framework');
      }
      if (setPersonaLabSelectFromPackageLabel(
        inspector,
        '[data-persona-lab-social-dynamics]',
        personaLabSocialDynamics,
        researchProfile.socialDynamicsLens || exportManifest.social_dynamics_lens
      )) {
        restored.push('social-dynamics lens');
      }
      if (setPersonaLabSelectFromPackageLabel(
        inspector,
        '[data-persona-lab-engagement]',
        personaLabEngagementPatterns,
        researchProfile.engagementPatternId || researchProfile.engagementPattern || exportManifest.engagement_pattern_id || exportManifest.engagement_pattern
      )) {
        restored.push('engagement pattern');
      }
      if (setPersonaLabSelectFromPackageLabel(
        inspector,
        '[data-persona-lab-runtime]',
        personaLabRuntimeFits,
        researchProfile.runtimeFit || exportManifest.runtime_fit
      )) {
        restored.push('runtime fit');
      }

      return restored;
    };
    const stagePersonaLabProfileRestore = (inspector) => {
      const inspection = inspector ? personaLabInspectionState.get(inspector) : null;
      if (!inspection || !inspection.canStage) {
        setStatus(t('portablePromptPersonaLabProfileRestoreUnavailable', 'Inspect a readable Spiralist AI package before loading a profile prompt.'));
        return false;
      }