codex-overleaf-link 1.1.1

package/extension/src/shared/storageKeys.js

@@ -0,0 +1,29 @@
+(function initStorageKeys(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafStorageKeys = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageKeysFactory() {
+  'use strict';
+
+  function getOverleafProjectId(urlLike) {
+    try {
+      const url = new URL(String(urlLike || ''));
+      const match = url.pathname.match(/^\/project\/([^/?#]+)/);
+      return match ? decodeURIComponent(match[1]) : '';
+    } catch {
+      return '';
+    }
+  }
+
+  function getProjectStorageKey(baseKey, urlLike) {
+    const projectId = getOverleafProjectId(urlLike);
+    return projectId ? `${baseKey}:project:${projectId}` : baseKey;
+  }
+
+  return {
+    getOverleafProjectId,
+    getProjectStorageKey
+  };
+});

package/extension/src/shared/storageMigration.js

@@ -0,0 +1,168 @@
+(function initStorageMigration(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafStorageMigration = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function storageMigrationFactory() {
+  'use strict';
+
+  var PREFS_KEY = 'codexOverleafPrefs';
+  var CUSTOM_INSTRUCTIONS_MAX_CHARS = 12000;
+  var PROJECT_PREF_KEY_MAX_CHARS = 160;
+
+  function runMigrationIfNeeded(projectId, legacyStorageKey) {
+    var StorageDb = (typeof window !== 'undefined' && window.CodexOverleafStorageDb)
+      ? window.CodexOverleafStorageDb
+      : require('./storageDb');
+    return chrome.storage.local.get([PREFS_KEY, legacyStorageKey]).then(function (stored) {
+      var prefs = normalizePrefs(stored[PREFS_KEY] || {});
+      var schemaVersion = prefs.storageSchemaVersion || 0;
+
+      if (schemaVersion >= StorageDb.TARGET_SCHEMA_VERSION) {
+        var activeSessionByProject = prefs.activeSessionByProject || {};
+        var activeSessionId = activeSessionByProject[projectId] || '';
+        return StorageDb.getAllByIndex('sessions', 'projectId', projectId).then(function (sessions) {
+          return { prefs: prefs, sessions: sessions, activeSessionId: activeSessionId, migrated: false };
+        });
+      }
+
+      // Migration v0 → v1
+      var legacyBlob = stored[legacyStorageKey] || {};
+      var legacySessions = Array.isArray(legacyBlob.sessions) ? legacyBlob.sessions : [];
+      var migratedSessions = [];
+
+      for (var i = 0; i < legacySessions.length; i++) {
+        var legacy = legacySessions[i];
+        if (!legacy || !legacy.id) { continue; }
+        var record = StorageDb.buildSessionRecord(
+          buildLegacySessionRecordInput(projectId, legacyBlob, legacy)
+        );
+        migratedSessions.push(record);
+      }
+
+      var putPromise = migratedSessions.length
+        ? StorageDb.putRecords('sessions', migratedSessions)
+        : Promise.resolve([]);
+
+      return putPromise.then(function () {
+        var newPrefs = StorageDb.extractLightweightPrefs(legacyBlob, projectId);
+        newPrefs.activeSessionByProject = StorageDb.buildActiveSessionByProject(
+          {},
+          projectId,
+          legacyBlob.activeSessionId || (migratedSessions.length ? migratedSessions[migratedSessions.length - 1].id : '')
+        );
+        newPrefs = normalizePrefs(newPrefs);
+
+        return chrome.storage.local.set({ [PREFS_KEY]: newPrefs }).then(function () {
+          return chrome.storage.local.remove(legacyStorageKey).catch(function () {});
+        }).then(function () {
+          return {
+            prefs: newPrefs,
+            sessions: migratedSessions,
+            activeSessionId: newPrefs.activeSessionByProject[projectId] || '',
+            migrated: true
+          };
+        });
+      });
+    });
+  }
+
+  function buildLegacySessionRecordInput(projectId, legacyBlob, legacy) {
+    return {
+      id: legacy.id,
+      projectId: projectId,
+      title: legacy.title || '',
+      titleSource: legacy.titleSource === 'manual' ? 'manual' : 'auto',
+      codexThreadId: '',
+      status: 'active',
+      focusFiles: Array.isArray(legacy.focusFiles) ? legacy.focusFiles : [],
+      history: Array.isArray(legacy.history) ? legacy.history : [],
+      runs: Array.isArray(legacy.runs) ? legacy.runs : [],
+      task: typeof legacy.task === 'string' ? legacy.task : '',
+      mode: typeof legacy.mode === 'string' ? legacy.mode : legacyBlob.mode || '',
+      model: typeof legacy.model === 'string' ? legacy.model : legacyBlob.model || '',
+      reasoningEffort: typeof legacy.reasoningEffort === 'string' ? legacy.reasoningEffort : legacyBlob.reasoningEffort || '',
+      speedTier: typeof legacy.speedTier === 'string' ? legacy.speedTier : legacyBlob.speedTier || '',
+      requireReviewing: legacy.requireReviewing !== false && legacyBlob.requireReviewing !== false,
+      createdAt: legacy.createdAt,
+      updatedAt: legacy.updatedAt
+    };
+  }
+
+  function savePrefs(prefs) {
+    return chrome.storage.local.set({ [PREFS_KEY]: normalizePrefs(prefs) });
+  }
+
+  function loadPrefs() {
+    return chrome.storage.local.get([PREFS_KEY]).then(function (stored) {
+      return normalizePrefs(stored[PREFS_KEY] || {});
+    });
+  }
+
+  function normalizePrefs(prefs) {
+    var source = prefs && typeof prefs === 'object' ? prefs : {};
+    return Object.assign({}, source, {
+      experimentalOtByProject: normalizeBooleanMap(source.experimentalOtByProject),
+      customInstructionsByProject: normalizeStringMap(source.customInstructionsByProject)
+    });
+  }
+
+  function normalizeBooleanMap(value) {
+    var result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return result;
+    }
+    var keys = Object.keys(value);
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+      if (!key) {
+        continue;
+      }
+      result[key] = value[key] === true;
+    }
+    return result;
+  }
+
+  function normalizeStringMap(value) {
+    var result = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return result;
+    }
+    var keys = Object.keys(value);
+    for (var i = 0; i < keys.length; i++) {
+      var rawKey = keys[i];
+      var key = normalizeProjectPrefKey(rawKey);
+      if (!key) {
+        continue;
+      }
+      result[key] = typeof value[rawKey] === 'string'
+        ? normalizeTextField(value[rawKey], CUSTOM_INSTRUCTIONS_MAX_CHARS)
+        : '';
+    }
+    return result;
+  }
+
+  function normalizeProjectPrefKey(value) {
+    var key = typeof value === 'string' ? value.trim() : '';
+    if (!key) {
+      return '';
+    }
+    return normalizeTextField(key, PROJECT_PREF_KEY_MAX_CHARS);
+  }
+
+  function normalizeTextField(value, maxChars) {
+    var text = typeof value === 'string' ? value : '';
+    if (!Number.isFinite(maxChars) || maxChars <= 0 || text.length <= maxChars) {
+      return text;
+    }
+    return text.slice(0, Math.max(0, maxChars - 1)) + '…';
+  }
+
+  return {
+    PREFS_KEY: PREFS_KEY,
+    runMigrationIfNeeded: runMigrationIfNeeded,
+    savePrefs: savePrefs,
+    loadPrefs: loadPrefs
+  };
+});

package/extension/src/shared/summary.js

@@ -0,0 +1,248 @@
+(function initSummary(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafSummary = factory();
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : window, function summaryFactory() {
+  'use strict';
+
+  const HIGH_RISK_TYPES = ['delete', 'overwrite-binary', 'tracked-change-decision'];
+
+  const TYPE_TO_COUNT_KEY = {
+    edit: 'edit',
+    create: 'create',
+    rename: 'rename',
+    move: 'move',
+    delete: 'delete',
+    'overwrite-binary': 'binaryOverwrite',
+    'tracked-change-decision': 'trackedChangeDecision'
+  };
+
+  function emptyCounts() {
+    return {
+      edit: 0,
+      create: 0,
+      rename: 0,
+      move: 0,
+      delete: 0,
+      binaryOverwrite: 0,
+      trackedChangeDecision: 0
+    };
+  }
+
+  function buildOperationSummary(operations) {
+    const counts = emptyCounts();
+    const affectedFiles = new Set();
+    const deletePlan = [];
+
+    for (const operation of operations || []) {
+      const countKey = TYPE_TO_COUNT_KEY[operation.type];
+      if (countKey) {
+        counts[countKey] += 1;
+      }
+
+      addPath(affectedFiles, operation.path);
+      addPath(affectedFiles, operation.to);
+
+      if (operation.type === 'delete') {
+        deletePlan.push({
+          path: operation.path,
+          reason: operation.reason || 'No reason provided'
+        });
+      }
+    }
+
+    return {
+      counts,
+      affectedFiles: Array.from(affectedFiles).sort(),
+      deletePlan
+    };
+  }
+
+  function splitDeletePlan(operations) {
+    const immediate = [];
+    const needsConfirmation = [];
+
+    for (const operation of operations || []) {
+      if (HIGH_RISK_TYPES.includes(operation.type)) {
+        needsConfirmation.push(operation);
+      } else {
+        immediate.push(operation);
+      }
+    }
+
+    return {
+      immediate,
+      needsConfirmation
+    };
+  }
+
+  function buildChangeSummaryLine({
+    notes = '',
+    operations = [],
+    summary,
+    applyResults = [],
+    status,
+    deletePlanRejected = false
+  } = {}) {
+    if (status === 'rejected') {
+      return 'Summary: proposed changes were rejected; no project files changed.';
+    }
+
+    const results = normalizeApplyResults(applyResults);
+    const appliedOperations = collectAppliedOperations(results);
+    const skippedCount = countSkippedOperations(results);
+    const effectiveSummary = results.length > 0
+      ? buildOperationSummary(appliedOperations)
+      : normalizeSummary(summary) || buildOperationSummary(operations);
+
+    const changePhrase = describeCounts(effectiveSummary.counts);
+    const note = firstUsefulSentence(notes);
+    const segments = [`Summary: ${changePhrase}`];
+    const affectedFiles = formatAffectedFiles(effectiveSummary.affectedFiles);
+
+    if (affectedFiles && changePhrase !== 'no project files changed') {
+      segments[0] += ` (${affectedFiles})`;
+    }
+
+    if (changePhrase === 'no project files changed' && note) {
+      segments.push(note);
+    }
+
+    if (deletePlanRejected) {
+      segments.push('delete plan was not applied');
+    }
+
+    if (skippedCount > 0) {
+      segments.push(`${skippedCount} ${pluralize('operation', skippedCount)} skipped`);
+    }
+
+    return ensureTerminalPeriod(segments.join('; '));
+  }
+
+  function addPath(paths, filePath) {
+    if (typeof filePath === 'string' && filePath.length > 0) {
+      paths.add(filePath);
+    }
+  }
+
+  function normalizeApplyResults(applyResults) {
+    if (!applyResults) {
+      return [];
+    }
+    return Array.isArray(applyResults) ? applyResults.filter(Boolean) : [applyResults];
+  }
+
+  function collectAppliedOperations(applyResults) {
+    const operations = [];
+    for (const result of applyResults) {
+      for (const item of getApplyResultEntries(result, 'applied')) {
+        if (item?.operation) {
+          operations.push(item.operation);
+        }
+      }
+    }
+    return operations;
+  }
+
+  function countSkippedOperations(applyResults) {
+    return applyResults.reduce((count, result) => count + getApplyResultEntries(result, 'skipped').length, 0);
+  }
+
+  function hasSkippedApplyOperations(applyResults) {
+    return countSkippedOperations(normalizeApplyResults(applyResults)) > 0;
+  }
+
+  function getApplyResultEntries(result, key) {
+    const entries = result?.[key];
+    return Array.isArray(entries) ? entries : [];
+  }
+
+  function normalizeSummary(summary) {
+    if (!summary?.counts) {
+      return null;
+    }
+    return {
+      counts: {
+        ...emptyCounts(),
+        ...summary.counts
+      },
+      affectedFiles: Array.isArray(summary.affectedFiles) ? summary.affectedFiles : [],
+      deletePlan: Array.isArray(summary.deletePlan) ? summary.deletePlan : []
+    };
+  }
+
+  function describeCounts(counts = emptyCounts()) {
+    const parts = [];
+    addCountPart(parts, counts.edit, 'edited', 'file');
+    addCountPart(parts, counts.create, 'created', 'file');
+    addCountPart(parts, counts.rename, 'renamed', 'file');
+    addCountPart(parts, counts.move, 'moved', 'file');
+    addCountPart(parts, counts.delete, 'deleted', 'file');
+    addCountPart(parts, counts.binaryOverwrite, 'overwrote', 'binary file');
+    addCountPart(parts, counts.trackedChangeDecision, 'handled', 'tracked-change decision');
+
+    return joinParts(parts) || 'no project files changed';
+  }
+
+  function addCountPart(parts, count, verb, noun) {
+    if (count > 0) {
+      parts.push(`${verb} ${count} ${pluralize(noun, count)}`);
+    }
+  }
+
+  function joinParts(parts) {
+    if (parts.length <= 1) {
+      return parts[0] || '';
+    }
+    return `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`;
+  }
+
+  function pluralize(noun, count) {
+    if (count === 1) {
+      return noun;
+    }
+    if (noun.endsWith('y')) {
+      return `${noun.slice(0, -1)}ies`;
+    }
+    return `${noun}s`;
+  }
+
+  function formatAffectedFiles(files = []) {
+    const unique = Array.from(new Set(files.filter(file => typeof file === 'string' && file.length > 0))).sort();
+    if (unique.length === 0) {
+      return '';
+    }
+    if (unique.length <= 4) {
+      return unique.join(', ');
+    }
+    return `${unique.slice(0, 4).join(', ')}, +${unique.length - 4} more`;
+  }
+
+  function firstUsefulSentence(text) {
+    const compact = String(text || '').replace(/\s+/g, ' ').trim();
+    if (!compact) {
+      return '';
+    }
+
+    const match = compact.match(/^(.{1,220}?[.!?。！？])(?:\s|$)/);
+    if (match) {
+      return match[1];
+    }
+
+    return compact.length > 220 ? `${compact.slice(0, 217)}...` : compact;
+  }
+
+  function ensureTerminalPeriod(text) {
+    return /[.!?。！？]$/.test(text) ? text : `${text}.`;
+  }
+
+  return {
+    HIGH_RISK_TYPES,
+    buildChangeSummaryLine,
+    buildOperationSummary,
+    hasSkippedApplyOperations,
+    splitDeletePlan
+  };
+});