docs-combiner 0.2.2 → 1.0.0

package/dist/models.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Конфигурация моделей для генерации контента
+ * Здесь можно легко изменить модели для разных задач
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODELS = void 0;
+exports.MODELS = {
+    // Модель для генерации заголовков и текстов
+    contentGeneration: 'openai/gpt-5.2',
+    // Модель для генерации изображений креативов
+    // imageGeneration: 'openai/gpt-5-image',
+    imageGeneration: 'openai/gpt-5-image-mini',
+    // Модель для валидации креативов
+    // creativeValidation: 'openai/gpt-4o',
+    creativeValidation: 'openai/gpt-5.2-pro',
+};

package/dist/offerSettings.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFER_SETTINGS_FILENAME = void 0;
+exports.parseOfferSettingsData = parseOfferSettingsData;
+exports.OFFER_SETTINGS_FILENAME = 'offer-settings.json';
+/** Разбор offer-settings.json из папки оффера. */
+function parseOfferSettingsData(data) {
+    const empty = { generateProduct: '', generateAdditionalInfo: '' };
+    if (!data || typeof data !== 'object')
+        return empty;
+    const settings = data.aiGenerationSettings;
+    if (!settings || typeof settings !== 'object')
+        return empty;
+    const ai = settings;
+    return {
+        generateProduct: typeof ai.generateProduct === 'string' ? ai.generateProduct : '',
+        generateAdditionalInfo: typeof ai.generateAdditionalInfo === 'string' ? ai.generateAdditionalInfo : '',
+    };
+}

package/dist/preload.js

@@ -58,6 +58,34 @@ electron_1.contextBridge.exposeInMainWorld('electronAPI', {
     reopenPendingAuthBrowser: () => electron_1.ipcRenderer.invoke('reopen-pending-auth-browser'),
     cancelPendingAuth: () => electron_1.ipcRenderer.invoke('cancel-pending-auth'),
     openExternal: (url) => electron_1.ipcRenderer.invoke('open-external', url),
+    registerWorkspaceFolder: (folderId) => electron_1.ipcRenderer.invoke('register-workspace-folder', folderId),
+    unregisterWorkspaceFolder: (folderId) => electron_1.ipcRenderer.invoke('unregister-workspace-folder', folderId),
+    newWindow: (workspaceId) => electron_1.ipcRenderer.invoke('new-window', workspaceId),
+    loadWorkspaceSnapshot: (workspaceId) => electron_1.ipcRenderer.invoke('load-workspace-snapshot', workspaceId),
+    saveWorkspaceSnapshot: (snapshot) => electron_1.ipcRenderer.invoke('save-workspace-snapshot', snapshot),
+    setWorkspaceWindowMeta: (payload) => electron_1.ipcRenderer.invoke('set-workspace-window-meta', payload),
+    listWorkspaceWindows: () => electron_1.ipcRenderer.invoke('list-workspace-windows'),
+    focusWorkspaceWindow: (webContentsId) => electron_1.ipcRenderer.invoke('focus-workspace-window', webContentsId),
+    closeWorkspaceWindow: (webContentsId) => electron_1.ipcRenderer.invoke('close-workspace-window', webContentsId),
+    closeAllWorkspaceWindows: () => electron_1.ipcRenderer.invoke('close-all-workspace-windows'),
+    closeOtherWorkspaceWindows: () => electron_1.ipcRenderer.invoke('close-other-workspace-windows'),
+    getAgentControlMode: () => electron_1.ipcRenderer.invoke('get-agent-control-mode'),
+    releaseAgentControl: () => electron_1.ipcRenderer.invoke('release-agent-control'),
+    onAgentControlModeChanged: (callback) => {
+        const listener = (_event, payload) => callback(payload);
+        electron_1.ipcRenderer.on('agent-control-mode-changed', listener);
+        return () => electron_1.ipcRenderer.removeListener('agent-control-mode-changed', listener);
+    },
+    onWorkspaceWindowsUpdated: (callback) => {
+        const listener = (_event, windows) => callback(windows);
+        electron_1.ipcRenderer.on('workspace-windows-updated', listener);
+        return () => electron_1.ipcRenderer.removeListener('workspace-windows-updated', listener);
+    },
+    onConfigUpdated: (callback) => {
+        const listener = (_event, config) => callback(config);
+        electron_1.ipcRenderer.on('config-updated', listener);
+        return () => electron_1.ipcRenderer.removeListener('config-updated', listener);
+    },
     log: (level, ...args) => electron_1.ipcRenderer.invoke('log', level, ...args),
     telegramSendTest: (botToken, chatId) => electron_1.ipcRenderer.invoke('telegram-send-test', { botToken, chatId }),
     telegramSendMessage: (botToken, chatId, text) => electron_1.ipcRenderer.invoke('telegram-send-message', { botToken, chatId, text }),

package/dist/promptOverrides.js

@@ -0,0 +1,437 @@
+"use strict";
+/**
+ * Утилиты для работы с oверрайдами промптов
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_OVERRIDES_SAVED_EVENT = exports.MAX_IMAGES_PER_CREO_APPROACH = exports.PRODUCT_TYPE_IMAGE_PRESETS = exports.PRODUCT_TYPE_TEXT_PAIR_PRESETS = void 0;
+exports.productPresetNumbersToIndices = productPresetNumbersToIndices;
+exports.productPresetNumbersToImageCounts = productPresetNumbersToImageCounts;
+exports.getSelectedPairApproaches = getSelectedPairApproaches;
+exports.getPairsCount = getPairsCount;
+exports.normalizeImageApproachCountsLength = normalizeImageApproachCountsLength;
+exports.normalizeApproachMatrixFromDrive = normalizeApproachMatrixFromDrive;
+exports.textApproachIndicesFromMatrix = textApproachIndicesFromMatrix;
+exports.imageApproachCountsFromMatrix = imageApproachCountsFromMatrix;
+exports.normalizeSelectedPairApproachesFromDrive = normalizeSelectedPairApproachesFromDrive;
+exports.normalizeImageApproachCountsFromDrive = normalizeImageApproachCountsFromDrive;
+exports.getImageBulletsGlobalOff = getImageBulletsGlobalOff;
+exports.getImageApproachNoBulletsMode = getImageApproachNoBulletsMode;
+exports.getImageApproachCounts = getImageApproachCounts;
+exports.loadPromptOverrides = loadPromptOverrides;
+exports.savePromptOverrides = savePromptOverrides;
+exports.parseApproachesFromDriveData = parseApproachesFromDriveData;
+exports.applyParsedApproachesFromDrive = applyParsedApproachesFromDrive;
+exports.mergePromptApproachesFromDriveFile = mergePromptApproachesFromDriveFile;
+exports.getPromptOverride = getPromptOverride;
+exports.setPromptOverride = setPromptOverride;
+exports.getCreoApproachOverride = getCreoApproachOverride;
+exports.setCreoApproachOverride = setCreoApproachOverride;
+exports.resetPromptOverride = resetPromptOverride;
+exports.resetCreoApproachOverride = resetCreoApproachOverride;
+exports.resetAllOverrides = resetAllOverrides;
+exports.loadOverridesFromElectron = loadOverridesFromElectron;
+const prompts_1 = require("./prompts");
+const STORAGE_KEY = 'promptOverrides';
+function stripWorkspaceSelections(overrides) {
+    const next = Object.assign({}, overrides);
+    delete next.selectedPairApproaches;
+    delete next.imageApproachCounts;
+    delete next.approachMatrixEnabled;
+    delete next.approachMatrix;
+    delete next.selectedImageApproaches;
+    delete next.pairsCount;
+    return next;
+}
+/** Номера 1–10 = строка в таблице подходов (PAIR_APPROACH_POOL[i] → номер i + 1). Порядок в массиве не важен — при применении сортируется по номеру строки. */
+exports.PRODUCT_TYPE_TEXT_PAIR_PRESETS = {
+    Похудение: [3, 1, 7, 8, 5],
+    Суставы: [3, 2, 8, 1, 10, 7],
+    Потенция: [6, 2, 1, 10, 8, 3],
+    Простатит: [3, 5, 8, 6, 7, 10],
+    Детокс: [10, 6, 3],
+};
+/** Номера 1–N = строка в таблице (CREO_APPROACHES[i] → i + 1). Стабильны: новые подходы только в конец массива. */
+exports.PRODUCT_TYPE_IMAGE_PRESETS = {
+    Похудение: [2, 8, 3, 5],
+    Суставы: [4, 6, 8, 10, 3, 5],
+    Потенция: [5, 10, 1, 8, 4, 2],
+    Простатит: [7, 6, 9, 1, 5, 8],
+    Детокс: [9, 9, 1, 1],
+};
+/** Индексы PAIR_APPROACH_POOL (0-based), по возрастанию. */
+function productPresetNumbersToIndices(oneBased) {
+    const poolLen = 10;
+    const seen = new Set();
+    for (const n of oneBased) {
+        const i = n - 1;
+        if (i >= 0 && i < poolLen)
+            seen.add(i);
+    }
+    return [...seen].sort((a, b) => a - b);
+}
+/**
+ * Пресет типа товара → массив длиной CREO_APPROACHES.length.
+ * Повтор номера увеличивает количество крео для подхода: [9, 9, 1, 1] => C9 x2 и C1 x2.
+ */
+function productPresetNumbersToImageCounts(oneBased) {
+    const counts = Array(imageApproachPoolSize()).fill(0);
+    for (const n of oneBased) {
+        const i = n - 1;
+        if (i >= 0 && i < imageApproachPoolSize()) {
+            counts[i] = Math.min(exports.MAX_IMAGES_PER_CREO_APPROACH, counts[i] + 1);
+        }
+    }
+    return counts;
+}
+// Debug logging — пишет в терминал Electron (или в console как fallback)
+function _debugLog(...args) {
+    if (typeof localStorage === 'undefined' ||
+        localStorage.getItem('promptOverridesDebug') !== 'true') {
+        return;
+    }
+    const api = typeof window !== 'undefined' ? window.electronAPI : null;
+    if (api === null || api === void 0 ? void 0 : api.log) {
+        api.log('log', '[PromptOverrides]', ...args).catch(() => console.log('[PromptOverrides]', ...args));
+    }
+    else {
+        console.log('[PromptOverrides]', ...args);
+    }
+}
+/**
+ * Получить выбранные индексы подходов (из PAIR_APPROACH_POOL).
+ * По умолчанию — первые 3 (индексы [0, 1, 2]).
+ */
+function getSelectedPairApproaches() {
+    const overrides = loadPromptOverrides();
+    if (overrides.selectedPairApproaches && overrides.selectedPairApproaches.length >= 2) {
+        return overrides.selectedPairApproaches;
+    }
+    // backward compat: если был старый pairsCount
+    if (overrides.pairsCount && overrides.pairsCount >= 2) {
+        return Array.from({ length: Math.min(10, overrides.pairsCount) }, (_, i) => i);
+    }
+    return [0, 1, 2]; // default: first 3 approaches
+}
+/**
+ * Получить количество пар (длина выбранных подходов)
+ */
+function getPairsCount() {
+    return getSelectedPairApproaches().length;
+}
+/** Количество подходов для изображений (= CREO_APPROACHES.length). */
+function imageApproachPoolSize() {
+    return prompts_1.CREO_APPROACHES.length;
+}
+/** Дополнить/обрезать массив counts до актуального числа подходов (новые слоты = 1). */
+function normalizeImageApproachCountsLength(counts) {
+    const size = imageApproachPoolSize();
+    const next = counts.map(c => Math.max(0, Math.min(exports.MAX_IMAGES_PER_CREO_APPROACH, c)));
+    while (next.length < size)
+        next.push(1);
+    return next.slice(0, size);
+}
+/** Максимум картинок на один визуальный подход (слоты в UI и clamp при загрузке). */
+exports.MAX_IMAGES_PER_CREO_APPROACH = 10;
+const PAIR_APPROACH_POOL_LEN = 10;
+/** Нормализация JSON-матрицы связок (номера 1–10, порядок строк сохраняется). */
+function normalizeApproachMatrixFromDrive(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    const out = [];
+    for (const row of raw) {
+        if (!Array.isArray(row) || row.length < 2)
+            return null;
+        const imageNumber = typeof row[0] === 'number' && Number.isInteger(row[0])
+            ? row[0]
+            : parseInt(String(row[0]), 10);
+        if (!Number.isInteger(imageNumber) || imageNumber < 1 || imageNumber > imageApproachPoolSize()) {
+            return null;
+        }
+        const rawTexts = row[1];
+        if (!Array.isArray(rawTexts))
+            return null;
+        const seenTexts = new Set();
+        const textNumbers = [];
+        for (const item of rawTexts) {
+            const textNumber = typeof item === 'number' && Number.isInteger(item)
+                ? item
+                : parseInt(String(item), 10);
+            if (!Number.isInteger(textNumber) || textNumber < 1 || textNumber > PAIR_APPROACH_POOL_LEN) {
+                return null;
+            }
+            if (!seenTexts.has(textNumber)) {
+                seenTexts.add(textNumber);
+                textNumbers.push(textNumber);
+            }
+        }
+        if (textNumbers.length === 0)
+            return null;
+        out.push([imageNumber, textNumbers]);
+    }
+    return out.length > 0 ? out : null;
+}
+function textApproachIndicesFromMatrix(matrix) {
+    const seen = new Set();
+    const out = [];
+    for (const [, textNumbers] of matrix) {
+        for (const n of textNumbers) {
+            const idx = n - 1;
+            if (idx >= 0 && idx < PAIR_APPROACH_POOL_LEN && !seen.has(idx)) {
+                seen.add(idx);
+                out.push(idx);
+            }
+        }
+    }
+    return out;
+}
+function imageApproachCountsFromMatrix(matrix) {
+    const counts = Array(imageApproachPoolSize()).fill(0);
+    for (const [imageNumber] of matrix) {
+        const idx = imageNumber - 1;
+        if (idx >= 0 && idx < imageApproachPoolSize()) {
+            counts[idx] = Math.min(exports.MAX_IMAGES_PER_CREO_APPROACH, counts[idx] + 1);
+        }
+    }
+    return counts;
+}
+/** Нормализация индексов пар из JSON с диска (0-based, уникальные, отсортированные, минимум 2). */
+function normalizeSelectedPairApproachesFromDrive(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    const seen = new Set();
+    for (const x of raw) {
+        const n = typeof x === 'number' && Number.isInteger(x) ? x : parseInt(String(x), 10);
+        if (Number.isInteger(n) && n >= 0 && n < PAIR_APPROACH_POOL_LEN)
+            seen.add(n);
+    }
+    const out = [...seen].sort((a, b) => a - b);
+    return out.length >= 2 ? out : null;
+}
+/** Нормализация количеств крео из JSON с диска (длина 10, 0–MAX; хотя бы один подход > 0). */
+function normalizeImageApproachCountsFromDrive(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    const out = [];
+    for (let i = 0; i < imageApproachPoolSize(); i++) {
+        const v = raw[i];
+        const n = typeof v === 'number' && Number.isFinite(v) ? v : parseInt(String(v), 10);
+        out.push(Number.isFinite(n) ? Math.max(0, Math.min(exports.MAX_IMAGES_PER_CREO_APPROACH, Math.round(n))) : 0);
+    }
+    if (out.every(c => c === 0))
+        return null;
+    return out;
+}
+/**
+ * «Везде без обязательных буллетов» (генерация + валидатор). Через `promptOverrides` (localStorage).
+ */
+function getImageBulletsGlobalOff() {
+    return Boolean(loadPromptOverrides().imageBulletsGlobalOff);
+}
+/** Режим буллетов для крео-подхода; без записи = default. */
+function getImageApproachNoBulletsMode(approachName) {
+    var _a;
+    const raw = (_a = loadPromptOverrides().imageApproachNoBulletsMode) === null || _a === void 0 ? void 0 : _a[approachName];
+    if (raw === 'off' || raw === 'on' || raw === 'default')
+        return raw;
+    return 'default';
+}
+/**
+ * Получить количество изображений по каждому подходу (N элементов, 0–MAX_IMAGES_PER_CREO_APPROACH).
+ * По умолчанию — по 1 на каждый подход.
+ */
+function getImageApproachCounts() {
+    const overrides = loadPromptOverrides();
+    const defaultCounts = Array(imageApproachPoolSize()).fill(1);
+    if (overrides.imageApproachCounts && overrides.imageApproachCounts.length > 0) {
+        return normalizeImageApproachCountsLength(overrides.imageApproachCounts);
+    }
+    // backward compat: selectedImageApproaches -> counts (1 for selected, 0 for not)
+    if (overrides.selectedImageApproaches && overrides.selectedImageApproaches.length >= 1) {
+        const counts = Array(imageApproachPoolSize()).fill(0);
+        for (const i of overrides.selectedImageApproaches) {
+            if (i >= 0 && i < imageApproachPoolSize())
+                counts[i] = 1;
+        }
+        return counts;
+    }
+    return defaultCounts;
+}
+/**
+ * Загрузить оверрайды из localStorage
+ */
+function loadPromptOverrides() {
+    if (typeof localStorage === 'undefined')
+        return {};
+    try {
+        const stored = localStorage.getItem(STORAGE_KEY);
+        if (stored) {
+            return JSON.parse(stored);
+        }
+    }
+    catch (err) {
+        console.error('Failed to load prompt overrides:', err);
+    }
+    return {};
+}
+/**
+ * Сохранить оверрайды в localStorage
+ */
+function savePromptOverrides(overrides) {
+    try {
+        const globalOverrides = stripWorkspaceSelections(overrides);
+        localStorage.setItem(STORAGE_KEY, JSON.stringify(globalOverrides));
+        // Также сохраняем через Electron API если доступно
+        const electronAPI = window.electronAPI;
+        if (electronAPI && electronAPI.saveConfig) {
+            electronAPI.loadConfig().then((config) => {
+                electronAPI.saveConfig(Object.assign(Object.assign({}, config), { promptOverrides: globalOverrides })).catch((err) => {
+                    console.error('Failed to save prompt overrides via Electron:', err);
+                });
+            }).catch(() => {
+                // Ignore
+            });
+        }
+    }
+    catch (err) {
+        console.error('Failed to save prompt overrides:', err);
+    }
+}
+/** Имя события после сохранения подходов в менеджере промптов — чтобы синхронизировать JSON на Drive. */
+exports.PROMPT_OVERRIDES_SAVED_EVENT = 'docs-combiner-prompt-overrides-saved';
+/** Прочитать валидные подходы из объекта настроек с диска (без записи в localStorage). */
+function parseApproachesFromDriveData(loadedData) {
+    const matrix = normalizeApproachMatrixFromDrive(loadedData.approachMatrix);
+    let matrixEnabled;
+    if (typeof loadedData.approachMatrixEnabled === 'boolean')
+        matrixEnabled = loadedData.approachMatrixEnabled;
+    else
+        matrixEnabled = matrix ? true : null;
+    return {
+        pairs: normalizeSelectedPairApproachesFromDrive(loadedData.selectedPairApproaches),
+        counts: normalizeImageApproachCountsFromDrive(loadedData.imageApproachCounts),
+        matrixEnabled,
+        matrix,
+    };
+}
+/**
+ * Legacy helper: selected approaches are no longer part of global prompt overrides.
+ * New code should keep them in per-window state and project-settings.json.
+ */
+function applyParsedApproachesFromDrive(pairs, counts) {
+    if (!pairs && !counts)
+        return false;
+    const overrides = loadPromptOverrides();
+    let dirty = false;
+    if (pairs) {
+        overrides.selectedPairApproaches = pairs;
+        dirty = true;
+    }
+    if (counts) {
+        overrides.imageApproachCounts = counts;
+        dirty = true;
+    }
+    if (dirty) {
+        savePromptOverrides(overrides);
+        return true;
+    }
+    return false;
+}
+/**
+ * Подмешать в localStorage выбранные подходы из project-settings.json на Drive (если поля валидны).
+ */
+function mergePromptApproachesFromDriveFile(loadedData) {
+    const { pairs, counts } = parseApproachesFromDriveData(loadedData);
+    return applyParsedApproachesFromDrive(pairs, counts);
+}
+/**
+ * Получить оверрайд для простого промпта
+ */
+function getPromptOverride(promptName) {
+    const overrides = loadPromptOverrides();
+    const result = overrides[promptName];
+    _debugLog(`getPromptOverride('${promptName}'):`, `found=${!!result}`, `enabled=${result === null || result === void 0 ? void 0 : result.enabled}`, `hasCustomPrompt=${!!(result === null || result === void 0 ? void 0 : result.customPrompt)}`);
+    return result;
+}
+/**
+ * Установить оверрайд для простого промпта
+ */
+function setPromptOverride(promptName, override) {
+    const overrides = loadPromptOverrides();
+    overrides[promptName] = Object.assign(Object.assign({}, override), { lastModified: new Date().toISOString() });
+    savePromptOverrides(overrides);
+}
+/**
+ * Получить оверрайд для подхода креативов
+ */
+function getCreoApproachOverride(approachName) {
+    var _a;
+    const overrides = loadPromptOverrides();
+    return (_a = overrides.creoApproaches) === null || _a === void 0 ? void 0 : _a[approachName];
+}
+/**
+ * Установить оверрайд для подхода креативов
+ */
+function setCreoApproachOverride(approachName, override) {
+    const overrides = loadPromptOverrides();
+    if (!overrides.creoApproaches) {
+        overrides.creoApproaches = {};
+    }
+    overrides.creoApproaches[approachName] = Object.assign(Object.assign({}, override), { lastModified: new Date().toISOString() });
+    savePromptOverrides(overrides);
+}
+/**
+ * Сбросить оверрайд для простого промпта
+ */
+function resetPromptOverride(promptName) {
+    const overrides = loadPromptOverrides();
+    delete overrides[promptName];
+    savePromptOverrides(overrides);
+}
+/**
+ * Сбросить оверрайд для подхода креативов
+ */
+function resetCreoApproachOverride(approachName) {
+    const overrides = loadPromptOverrides();
+    if (overrides.creoApproaches) {
+        delete overrides.creoApproaches[approachName];
+        savePromptOverrides(overrides);
+    }
+}
+/**
+ * Сбросить все оверрайды
+ */
+function resetAllOverrides() {
+    localStorage.removeItem(STORAGE_KEY);
+    // Также очищаем в Electron config
+    const electronAPI = window.electronAPI;
+    if (electronAPI && electronAPI.saveConfig) {
+        electronAPI.loadConfig().then((config) => {
+            delete config.promptOverrides;
+            electronAPI.saveConfig(config).catch(() => {
+                // Ignore
+            });
+        }).catch(() => {
+            // Ignore
+        });
+    }
+}
+/**
+ * Загрузить оверрайды из Electron config при старте
+ */
+function loadOverridesFromElectron() {
+    const electronAPI = window.electronAPI;
+    if (electronAPI && electronAPI.loadConfig) {
+        electronAPI.loadConfig().then((config) => {
+            if (config.promptOverrides) {
+                try {
+                    localStorage.setItem(STORAGE_KEY, JSON.stringify(config.promptOverrides));
+                }
+                catch (err) {
+                    console.error('Failed to load prompt overrides from Electron:', err);
+                }
+            }
+        }).catch(() => {
+            // Ignore
+        });
+    }
+}