codex-overleaf-link 1.8.6 → 1.9.1

package/extension/src/content/reviewHunks.js

@@ -0,0 +1,247 @@
+(function initCodexOverleafReviewHunks(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafReviewHunks = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function reviewHunksFactory() {
+  'use strict';
+
+  function buildReviewModel(syncChanges = [], options = {}) {
+    const files = [];
+    const hunks = [];
+
+    for (const [changeIndex, change] of (syncChanges || []).entries()) {
+      const path = normalizePath(change?.path);
+      if (!path) {
+        continue;
+      }
+
+      const file = {
+        index: changeIndex,
+        type: change?.type,
+        path,
+        decisionKey: normalizeReviewDecisionKey(path),
+        reviewable: false,
+        hunks: []
+      };
+
+      if (isHunkReviewableChange(change, options)) {
+        file.reviewable = true;
+        file.hunks = normalizePatches(change.patches).map((patch, patchIndex) => {
+          const id = `${path}:hunk:${patchIndex}`;
+          return {
+            id,
+            path,
+            patchIndexes: [patchIndex],
+            startOffset: patch.from,
+            endOffset: patch.to,
+            startLine: getPatchStartLine(change, patchIndex),
+            lineCount: getPatchLineCount(patch),
+            canApplyIndependently: true,
+            truncated: false,
+            decisionKey: normalizeReviewDecisionKey(path, id)
+          };
+        });
+        hunks.push(...file.hunks);
+      }
+
+      files.push(file);
+    }
+
+    return {
+      files,
+      hunks
+    };
+  }
+
+  function buildAcceptedSyncChanges(syncChanges = [], decisions = {}) {
+    const model = buildReviewModel(syncChanges);
+    const filesByIndex = new Map(model.files.map(file => [file.index, file]));
+    const accepted = [];
+
+    for (const [changeIndex, change] of (syncChanges || []).entries()) {
+      const file = filesByIndex.get(changeIndex);
+      if (!file) {
+        continue;
+      }
+
+      if (!file.reviewable) {
+        if (isAcceptedDecision(decisions[file.decisionKey])) {
+          accepted.push(cloneSyncChange(change));
+        }
+        continue;
+      }
+
+      const acceptedPatchIndexes = [];
+      for (const hunk of file.hunks) {
+        if (isAcceptedDecision(decisions[hunk.decisionKey])) {
+          acceptedPatchIndexes.push(...hunk.patchIndexes);
+        }
+      }
+
+      if (acceptedPatchIndexes.length) {
+        const patches = normalizePatches(change.patches)
+          .filter((patch, patchIndex) => acceptedPatchIndexes.includes(patchIndex));
+        const clone = cloneSyncChange(change);
+        clone.patches = patches.map(patch => ({ ...patch }));
+        delete clone.replaceAll;
+        accepted.push(clone);
+      }
+    }
+
+    return accepted;
+  }
+
+  function summarizeReviewModel(model = {}) {
+    const files = Array.isArray(model.files) ? model.files : [];
+    return {
+      files: files.length,
+      hunks: files.reduce((count, file) => count + (Array.isArray(file.hunks) ? file.hunks.length : 0), 0),
+      fallbackFiles: files.filter(file => !file.reviewable).length,
+      reviewableFiles: files.filter(file => file.reviewable).length
+    };
+  }
+
+  function normalizeReviewDecisionKey(path, hunkId) {
+    const normalizedPath = normalizePath(path);
+    return `${normalizedPath || 'unknown'}::${hunkId || 'file'}`;
+  }
+
+  function isHunkReviewableChange(change = {}, options = {}) {
+    if (change.type !== 'write') {
+      return false;
+    }
+    if (hasTruncatedDisplayDiff(change)) {
+      return false;
+    }
+    const patches = Array.isArray(change.patches) ? change.patches : [];
+    if (!patches.length) {
+      return false;
+    }
+    return normalizePatches(patches).length === patches.length;
+  }
+
+  function hasTruncatedDisplayDiff(change = {}) {
+    if (!Array.isArray(change.diff)) {
+      return false;
+    }
+    return change.diff.some(hunk => hunk?.truncated === true);
+  }
+
+  function normalizePatches(patches = []) {
+    const normalized = [];
+    for (const patch of patches || []) {
+      const from = Number(patch?.from);
+      const to = Number(patch?.to);
+      if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to < from) {
+        continue;
+      }
+      normalized.push({
+        from,
+        to,
+        expected: String(patch.expected ?? ''),
+        insert: String(patch.insert ?? '')
+      });
+    }
+    return normalized;
+  }
+
+  function getPatchStartLine(change = {}, patchIndex = 0) {
+    const diffHunk = Array.isArray(change.diff) ? change.diff[patchIndex] : null;
+    const startB = Number(diffHunk?.startB);
+    if (Number.isInteger(startB) && startB > 0) {
+      return startB;
+    }
+    return undefined;
+  }
+
+  function getPatchLineCount(patch = {}) {
+    const text = String(patch.insert ?? patch.expected ?? '');
+    if (!text) {
+      return 1;
+    }
+    return Math.max(1, text.split('\n').length);
+  }
+
+  function normalizePath(path) {
+    return String(path || '').replace(/\\/g, '/').trim().replace(/^\/+/, '');
+  }
+
+  function isAcceptedDecision(decision) {
+    return decision === true || decision === 'accepted' || decision === 'accept';
+  }
+
+  function isRejectedDecision(decision) {
+    return decision === false || decision === 'rejected' || decision === 'reject';
+  }
+
+  // v1.7.5: summaries of what the user rejected during review, so the
+  // completion report can offer a one-click "redo the rejected changes"
+  // retry that quotes the location and a snippet of each dropped hunk.
+  function buildRejectedHunkSummaries(syncChanges = [], decisions = {}) {
+    const model = buildReviewModel(syncChanges);
+    const filesByIndex = new Map(model.files.map(file => [file.index, file]));
+    const rejected = [];
+    for (const [changeIndex, change] of (syncChanges || []).entries()) {
+      const file = filesByIndex.get(changeIndex);
+      if (!file) {
+        continue;
+      }
+      if (!file.reviewable) {
+        if (isRejectedDecision(decisions[file.decisionKey])) {
+          rejected.push({ path: file.path, summary: '' });
+        }
+        continue;
+      }
+      const patches = normalizePatches(change.patches);
+      for (const hunk of file.hunks) {
+        if (!isRejectedDecision(decisions[hunk.decisionKey])) {
+          continue;
+        }
+        const patch = patches[hunk.patchIndexes[0]] || {};
+        const snippet = String(patch.insert || '').trim().replace(/\s+/g, ' ').slice(0, 80);
+        rejected.push({
+          path: file.path,
+          summary: `${hunk.startLine ? `L${hunk.startLine}` : ''}${hunk.startLine && snippet ? ': ' : ''}${snippet}`
+        });
+      }
+    }
+    return rejected;
+  }
+
+  function cloneSyncChange(change) {
+    if (!change || typeof change !== 'object') {
+      return change;
+    }
+    const clone = { ...change };
+    if (Array.isArray(change.diff)) {
+      clone.diff = cloneArrayObjects(change.diff);
+    }
+    if (Array.isArray(change.patches)) {
+      clone.patches = cloneArrayObjects(change.patches);
+    }
+    return clone;
+  }
+
+  function cloneArrayObjects(items) {
+    return items.map(item => {
+      if (!item || typeof item !== 'object') {
+        return item;
+      }
+      const clone = { ...item };
+      if (Array.isArray(item.lines)) {
+        clone.lines = cloneArrayObjects(item.lines);
+      }
+      return clone;
+    });
+  }
+
+  return {
+    buildAcceptedSyncChanges,
+    buildRejectedHunkSummaries,
+    buildReviewModel,
+    normalizeReviewDecisionKey,
+    summarizeReviewModel
+  };
+});

package/extension/src/content/runController.js

@@ -0,0 +1,242 @@
+(function initCodexOverleafRunController(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafRunController = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function runControllerFactory() {
+  'use strict';
+
+  const DEFAULT_EXPECTED_MIRROR_FRESHNESS_MS = 5 * 60 * 1000;
+
+  function buildCodexRunParams({
+    currentProjectId,
+    state = {},
+    task,
+    project,
+    useExistingMirror,
+    fileOverlays,
+    focusFiles,
+    otWarmStart,
+    codexThreadId,
+    customInstructions,
+    skillLoadingSettings,
+    enabledCodexOverleafSkillIds,
+    attachments,
+    skillInvocation,
+    compileLogContext,
+    submittedMode,
+    restrictToFocusFiles
+  } = {}) {
+    const normalizedCustomInstructions = String(customInstructions || '').trim();
+    const normalizedAttachments = normalizeComposerAttachments(attachments);
+    const normalizedSkillInvocation = normalizeSkillInvocation(skillInvocation);
+    const normalizedEnabledSkillIds = Array.isArray(enabledCodexOverleafSkillIds)
+      ? enabledCodexOverleafSkillIds.filter(id => typeof id === 'string' && id.trim())
+      : undefined;
+    const params = {
+      projectId: currentProjectId,
+      mode: submittedMode || state.mode,
+      task,
+      project: useExistingMirror ? undefined : project,
+      useExistingMirror: useExistingMirror || undefined,
+      fileOverlays: useExistingMirror ? fileOverlays : undefined,
+      expectedMirrorFreshness: useExistingMirror ? DEFAULT_EXPECTED_MIRROR_FRESHNESS_MS : undefined,
+      otWarmStart: useExistingMirror && otWarmStart ? true : undefined,
+      warmStartStrategy: useExistingMirror && otWarmStart ? 'ot-warm-mirror' : undefined,
+      focusFiles,
+      restrictToFocusFiles: restrictToFocusFiles || undefined,
+      model: state.model,
+      reasoningEffort: state.reasoningEffort,
+      speedTier: state.speedTier,
+      session: state.session,
+      threadId: codexThreadId || undefined,
+      customInstructions: normalizedCustomInstructions || undefined,
+      loadCodexLocalSkills: skillLoadingSettings?.loadCodexLocalSkills !== false,
+      loadCodexOverleafSkills: skillLoadingSettings?.loadCodexOverleafSkills !== false,
+      enabledCodexOverleafSkillIds: normalizedEnabledSkillIds,
+      skillInvocation: normalizedSkillInvocation || undefined,
+      attachments: normalizedAttachments.length ? normalizedAttachments : undefined
+    };
+
+    if (compileLogContext?.available) {
+      params.compileLog = compileLogContext.log;
+      params.compileErrors = compileLogContext.errors || [];
+      params.compileWarnings = compileLogContext.warnings || [];
+      params.compileLogFresh = compileLogContext.fresh;
+      params.compileLogCompiledAt = compileLogContext.compiledAt;
+    }
+
+    return params;
+  }
+
+  function buildSessionHistoryResult({ assistantMessage = '', syncOutcome = {}, syncChanges = [], locale = 'zh' } = {}) {
+    const parts = [];
+    const finalAnswer = truncateSessionHistoryText(assistantMessage, 1600);
+    if (finalAnswer) {
+      parts.push(finalAnswer);
+    }
+
+    const changedFiles = Array.from(new Set((syncChanges || [])
+      .map(change => change?.path)
+      .filter(Boolean)));
+    if (changedFiles.length) {
+      const visibleFiles = changedFiles.slice(0, 8).join(', ');
+      parts.push(locale === 'en'
+        ? `Files changed: ${visibleFiles}${changedFiles.length > 8 ? ' and more' : ''}`
+        : `涉及文件：${visibleFiles}${changedFiles.length > 8 ? ' 等' : ''}`);
+    }
+
+    if (!parts.length) {
+      return truncateSessionHistoryText(syncOutcome.summaryLine || 'completed', 1600);
+    }
+    return truncateSessionHistoryText(parts.join('\n'), 2000);
+  }
+
+  function truncateSessionHistoryText(value, maxLength) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (!text || text.length <= maxLength) {
+      return text;
+    }
+    return `${text.slice(0, Math.max(0, maxLength - 1))}…`;
+  }
+
+  function canUseFocusedPartialSnapshot({
+    project = {},
+    snapshotWarnings = {},
+    focusFiles = [],
+    isUsableProjectFileContent = defaultIsUsableProjectFileContent
+  } = {}) {
+    const blocking = Array.isArray(snapshotWarnings.blocking) ? snapshotWarnings.blocking : [];
+    if (!blocking.length || !blocking.some(isFullSnapshotWarning)) {
+      return false;
+    }
+    const normalizedFocusFiles = normalizeFocusFiles(focusFiles);
+    if (!normalizedFocusFiles.length) {
+      return false;
+    }
+    if (project?.capabilities?.fullProjectSnapshot !== false) {
+      return false;
+    }
+
+    const textFilesByPath = new Map((project.files || [])
+      .filter(file => file && typeof file.path === 'string' && typeof file.content === 'string')
+      .map(file => [normalizeFocusPath(file.path), file]));
+
+    return normalizedFocusFiles.every(filePath => {
+      const file = textFilesByPath.get(normalizeFocusPath(filePath));
+      return file && isUsableProjectFileContent(file.content);
+    });
+  }
+
+  function shouldRestrictWritebackToFocus({ focusFiles = [] } = {}) {
+    return normalizeFocusFiles(focusFiles).length > 0;
+  }
+
+  function isFullSnapshotWarning(warning) {
+    return /Full project snapshot was not captured/i.test(String(warning || ''));
+  }
+
+  function normalizeFocusFiles(value) {
+    const seen = new Set();
+    const files = [];
+    for (const item of Array.isArray(value) ? value : []) {
+      const filePath = normalizeFocusPath(item);
+      if (!filePath || seen.has(filePath)) {
+        continue;
+      }
+      seen.add(filePath);
+      files.push(filePath);
+    }
+    return files;
+  }
+
+  function normalizeFocusPath(value) {
+    return String(value || '')
+      .replace(/^@file:/i, '')
+      .replace(/\\/g, '/')
+      .trim()
+      .replace(/^\/+/, '');
+  }
+
+  function normalizeComposerAttachments(value) {
+    const result = [];
+    for (const item of Array.isArray(value) ? value : []) {
+      const name = normalizeAttachmentName(item?.name);
+      const contentBase64 = normalizeAttachmentBase64(item?.contentBase64);
+      if (!name || !contentBase64) {
+        continue;
+      }
+      const size = Number(item?.size);
+      result.push({
+        name,
+        mimeType: String(item?.mimeType || '').trim().slice(0, 120),
+        size: Number.isFinite(size) && size >= 0 ? size : estimateBase64Size(contentBase64),
+        contentBase64
+      });
+      if (result.length >= 8) {
+        break;
+      }
+    }
+    return result;
+  }
+
+  function normalizeSkillInvocation(value) {
+    const id = String(value?.id || '').trim();
+    if (!isSafeSkillId(id)) {
+      return null;
+    }
+    const title = String(value?.title || 'Skill Installer').trim().slice(0, 80) || 'Skill Installer';
+    if (id === 'skill-installer') {
+      return { id, title };
+    }
+    if (value?.scope !== 'codex-overleaf') {
+      return null;
+    }
+    return { id, title, scope: 'codex-overleaf' };
+  }
+
+  function isSafeSkillId(id) {
+    return /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(String(id || ''))
+      && !String(id || '').includes('..');
+  }
+
+  function normalizeAttachmentName(value) {
+    return String(value || '')
+      .replace(/\0/g, '')
+      .replace(/\\/g, '/')
+      .split('/')
+      .filter(Boolean)
+      .pop()
+      ?.trim()
+      .slice(0, 180) || '';
+  }
+
+  function normalizeAttachmentBase64(value) {
+    const clean = String(value || '').replace(/\s+/g, '');
+    if (!clean || !/^[A-Za-z0-9+/]+={0,2}$/.test(clean)) {
+      return '';
+    }
+    return clean;
+  }
+
+  function estimateBase64Size(value) {
+    const clean = String(value || '').replace(/\s+/g, '');
+    const padding = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+    return Math.max(0, Math.floor(clean.length * 3 / 4) - padding);
+  }
+
+  function defaultIsUsableProjectFileContent(content) {
+    return String(content || '').trim().length > 0;
+  }
+
+  return {
+    buildCodexRunParams,
+    canUseFocusedPartialSnapshot,
+    shouldRestrictWritebackToFocus,
+    buildSessionHistoryResult,
+    truncateSessionHistoryText,
+    normalizeComposerAttachments,
+    normalizeSkillInvocation
+  };
+});