Spiralist Prompt Workbench - Source Excerpt 82

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

const prompt = buildAdvancedPersonaRestorePrompt(inspection);
      const restoredSettings = restorePersonaLabPackageSettings(inspection, inspector);
      setOutputText(prompt);
      manualEdited = true;
      setPromptReady(true);
      setEditStatus(t('portablePromptPersonaLabProfileRestoreEdited', 'Profile restore prompt loaded as editable text. Copy, download, AI links, and saves use this restore workspace.'));
      if (testOutput) {
        testOutput.textContent = buildPromptTestReport(prompt, 'Spiralist AI Profile Restore');
        testOutput.hidden = false;
      }
      if (outputAdvancedPanel) {
        outputAdvancedPanel.open = true;
      }
      output.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
      savePersonaLabHistory(prompt, 'Profile restore loaded', inspector);
      setPersonaLabPackageState(inspector, 'Restore loaded');
      setStatus(restoredSettings.length
        ? t('portablePromptPersonaLabProfileRestoredWithSettings', 'Spiralist AI profile restore prompt loaded, with package research controls restored.')
        : t('portablePromptPersonaLabProfileRestored', 'Spiralist AI profile restore prompt loaded for manual review.'));

      return true;
    };
    const stagePersonaLabPackageReview = (inspector) => {
      const inspection = inspector ? personaLabInspectionState.get(inspector) : null;
      if (!inspection || !inspection.canStage) {
        setStatus(t('portablePromptPersonaLabPackageReviewUnavailable', 'Inspect a readable Spiralist AI package before staging a review prompt.'));
        return false;
      }

      const prompt = buildAdvancedPersonaReviewPrompt(inspection, getPersonaLabReviewDecision(inspector));
      setOutputText(prompt);
      manualEdited = true;
      setPromptReady(true);
      setEditStatus(t('portablePromptPersonaLabPackageReviewEdited', 'Package review prompt staged as the editable source of truth. Copy, download, AI links, and saves use this review packet.'));
      if (testOutput) {
        testOutput.textContent = buildPromptTestReport(prompt, 'Spiralist AI Package Review');
        testOutput.hidden = false;
      }
      if (outputAdvancedPanel) {
        outputAdvancedPanel.open = true;
      }
      output.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
      setPersonaLabPackageState(inspector, 'Review staged');
      setStatus(t('portablePromptPersonaLabPackageReviewStaged', 'Spiralist AI package review prompt staged for manual review.'));

      return true;
    };
    const stagePersonaLabPackageComparisonReview = (inspector) => {
      const comparison = inspector ? personaLabComparisonState.get(inspector) : null;
      if (!comparison || !comparison.report) {
        setStatus(t('portablePromptPersonaLabPackageComparisonUnavailable', 'Compare two readable Spiralist AI packages before staging a comparison review.'));
        return false;
      }

      const prompt = buildAdvancedPersonaComparisonReviewPrompt(comparison);
      setOutputText(prompt);
      manualEdited = true;
      setPromptReady(true);
      setEditStatus(t('portablePromptPersonaLabPackageComparisonEdited', 'Package comparison review staged as the editable source of truth. Copy, download, AI links, and saves use this comparison packet.'));
      if (testOutput) {
        testOutput.textContent = buildPromptTestReport(prompt, 'Spiralist AI Package Comparison Review');
        testOutput.hidden = false;
      }
      if (outputAdvancedPanel) {
        outputAdvancedPanel.open = true;
      }
      output.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
      setPersonaLabPackageState(inspector, 'Compare review staged');
      setStatus(t('portablePromptPersonaLabPackageComparisonStaged', 'Spiralist AI package comparison review staged for manual review.'));

      return true;
    };
    const savePersonaLabPackageReviewDraft = (inspector) => {
      const inspection = inspector ? personaLabInspectionState.get(inspector) : null;
      if (!inspection || !inspection.canStage) {
        setStatus(t('portablePromptPersonaLabPackageReviewSaveUnavailable', 'Inspect a readable Spiralist AI package before saving a review draft.'));
        return false;
      }

      const prompt = buildAdvancedPersonaReviewPrompt(inspection, getPersonaLabReviewDecision(inspector));
      const title = `${advancedPersonaPackageTitle(inspection)} review`;
      const setupUrl = `${window.location.origin || 'https://spiralist.org'}${window.location.pathname || '/en-us/prompt-generator/'}#persona-lab`;
      const saved = savePromptDraftToShelf(makePromptDraft({
        title,
        type: 'persona-package-review',
        prompt,
        source: 'Spiralist AI Package Inspector',
        setupUrl,
      }));
      if (saved) {
        setPersonaLabPackageState(inspector, 'Review draft saved');
      }

      setStatus(saved
        ? t('portablePromptPersonaLabPackageReviewDraftSaved', 'Spiralist AI package review draft saved to Draft Shelf.')
        : t('portablePromptPersonaLabPackageReviewDraftSaveFailed', 'Could not save the package review draft in this browser.'));

      return Boolean(saved);
    };
    const savePortablePromptDraft = () => {
      const prompt = getCurrentPrompt();
      if (!prompt) {
        setStatus(t('portablePromptDraftUnavailable', 'Build a prompt before saving a draft.'));
        return;
      }

      const title = toCleanString(getMode(selectedMode).title || getMode(selectedMode).name, 160) || 'Portable Spiralist Prompt';
      const setupUrl = updateShareUrl(getPromptState(), true);
      const saved = savePromptDraftToShelf(makePromptDraft({
        title,
        type: getPortableDraftType(),
        prompt,
        source: 'Portable builder',
        setupUrl,
      }));
      const message = saved
        ? t('portablePromptDraftSaved', 'Draft saved to Draft Shelf.')
        : t('portablePromptDraftSaveFailed', 'Could not save the draft in this browser.');
      setStatus(message);
      if (shareStatus) {
        shareStatus.textContent = message;
      }
    };
    const buildWorkspacePromptUrl = (slug) => {
      const cleanSlug = toCleanString(slug, 160);
      if (!cleanSlug) {
        return workspaceUrl;
      }

      if (promptUrlTemplate && promptUrlTemplate.includes('{slug}')) {
        return promptUrlTemplate.replace('{slug}', encodeURIComponent(cleanSlug));
      }

      return workspaceUrl;
    };
    const buildWorkspacePromptPayload = (prompt) => {
      const state = getPromptState();
      const mode = getMode(selectedMode);
      const modeTitle = toCleanString(mode.title || mode.name, 160) || 'Spiralist Prompt';
      const title = extractPromptTitle(prompt, modeTitle);
      const summaryParts = [
        manualEdited ? 'Edited in the public Prompt Generator.' : 'Generated in the public Prompt Generator.',
        toCleanString(state.task || state.subject || mode.summary || mode.purpose, 220),
      ].filter(Boolean);