codex-overleaf-link 1.1.1

package/native-host/src/codexModels.js

@@ -0,0 +1,247 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { FALLBACK_MODELS } = require('../../extension/src/shared/models');
+const {
+  getPluginCodexHome,
+  getUserCodexHome
+} = require('./codexHome');
+
+const DEFAULT_REASONING_EFFORTS = Object.freeze(['low', 'medium', 'high', 'xhigh']);
+const DEFAULT_SPEED_TIERS = Object.freeze(['standard']);
+
+function resolveCodexModels(params = {}, env = process.env) {
+  const cacheResult = resolveModelsFromCodexCache(params, env);
+  if (cacheResult) {
+    return cacheResult;
+  }
+
+  return {
+    models: buildFallbackModels(),
+    source: 'fallback',
+    fetchedAt: new Date().toISOString()
+  };
+}
+
+function resolveModelsFromCodexCache(params, env) {
+  for (const cachePath of getModelsCacheCandidates(params, env)) {
+    const parsed = readModelsCache(cachePath);
+    if (!parsed) {
+      continue;
+    }
+    const models = normalizeCacheModels(parsed.value);
+    if (!models.length) {
+      continue;
+    }
+    return {
+      models,
+      source: 'codex-cache',
+      fetchedAt: getString(parsed.value?.fetched_at) || getString(parsed.value?.fetchedAt) || new Date().toISOString(),
+      clientVersion: getString(parsed.value?.client_version) || getString(parsed.value?.clientVersion) || ''
+    };
+  }
+  return null;
+}
+
+function getModelsCacheCandidates(params = {}, env = process.env) {
+  const candidates = [];
+  const addHome = home => {
+    if (!home || typeof home !== 'string') {
+      return;
+    }
+    candidates.push(path.join(path.resolve(home), 'models_cache.json'));
+  };
+
+  void params;
+  addHome(env.CODEX_HOME);
+  addHome(env.CODEX_OVERLEAF_USER_CODEX_HOME);
+  addHome(getUserCodexHome({ ...env, CODEX_HOME: '' }));
+  addHome(env.CODEX_OVERLEAF_CODEX_HOME);
+  addHome(getPluginCodexHome(env));
+
+  const seen = new Set();
+  return candidates.filter(cachePath => {
+    const normalized = path.resolve(cachePath);
+    if (seen.has(normalized)) {
+      return false;
+    }
+    seen.add(normalized);
+    return true;
+  });
+}
+
+function readModelsCache(cachePath) {
+  try {
+    const stat = fs.statSync(cachePath);
+    if (!stat.isFile()) {
+      return null;
+    }
+    return {
+      cachePath,
+      value: JSON.parse(fs.readFileSync(cachePath, 'utf8'))
+    };
+  } catch {
+    return null;
+  }
+}
+
+function normalizeCacheModels(cache) {
+  const rawModels = getRawModels(cache);
+  if (!rawModels.length) {
+    return [];
+  }
+
+  const models = [];
+  const seen = new Set();
+  for (const rawModel of rawModels) {
+    const model = normalizeCacheModel(rawModel);
+    if (!model || seen.has(model.id)) {
+      continue;
+    }
+    seen.add(model.id);
+    models.push(model);
+  }
+  return models;
+}
+
+function getRawModels(cache) {
+  if (Array.isArray(cache)) {
+    return cache;
+  }
+  if (!cache || typeof cache !== 'object') {
+    return [];
+  }
+  if (Array.isArray(cache.models)) {
+    return cache.models;
+  }
+  if (Array.isArray(cache.data)) {
+    return cache.data;
+  }
+  return [];
+}
+
+function normalizeCacheModel(rawModel) {
+  if (typeof rawModel === 'string') {
+    const id = rawModel.trim();
+    return id ? buildModelEntry({ id, label: id }) : null;
+  }
+  if (!rawModel || typeof rawModel !== 'object' || rawModel.visibility === 'hide') {
+    return null;
+  }
+
+  const id = getString(rawModel.slug)
+    || getString(rawModel.id)
+    || getString(rawModel.model)
+    || getString(rawModel.name);
+  if (!id) {
+    return null;
+  }
+
+  const label = getString(rawModel.display_name)
+    || getString(rawModel.displayName)
+    || getString(rawModel.label)
+    || getString(rawModel.name)
+    || id;
+  const reasoningEfforts = normalizeReasoningEfforts(
+    rawModel.supported_reasoning_levels
+      || rawModel.supportedReasoningLevels
+      || rawModel.reasoning_efforts
+      || rawModel.reasoningEfforts
+  );
+  const defaultReasoningEffort = getString(rawModel.default_reasoning_level)
+    || getString(rawModel.defaultReasoningLevel)
+    || getString(rawModel.default_reasoning_effort)
+    || getString(rawModel.defaultReasoningEffort);
+  const speedTiers = normalizeSpeedTiers(
+    rawModel.additional_speed_tiers
+      || rawModel.additionalSpeedTiers
+      || rawModel.speed_tiers
+      || rawModel.speedTiers
+  );
+  const defaultSpeedTier = getString(rawModel.default_speed_tier)
+    || getString(rawModel.defaultSpeedTier);
+
+  return buildModelEntry({
+    id,
+    label,
+    reasoningEfforts,
+    defaultReasoningEffort,
+    speedTiers,
+    defaultSpeedTier
+  });
+}
+
+function buildModelEntry({
+  id,
+  label,
+  reasoningEfforts = DEFAULT_REASONING_EFFORTS,
+  defaultReasoningEffort = 'medium',
+  speedTiers = DEFAULT_SPEED_TIERS,
+  defaultSpeedTier = 'standard'
+}) {
+  const normalizedEfforts = normalizeReasoningEfforts(reasoningEfforts);
+  const normalizedDefault = getString(defaultReasoningEffort) || 'medium';
+  const normalizedSpeedTiers = normalizeSpeedTiers(speedTiers);
+  const normalizedDefaultSpeedTier = getString(defaultSpeedTier) || 'standard';
+  return {
+    id,
+    label,
+    reasoningEfforts: normalizedEfforts.length ? normalizedEfforts : DEFAULT_REASONING_EFFORTS.slice(),
+    defaultReasoningEffort: normalizedDefault,
+    speedTiers: normalizedSpeedTiers.length ? normalizedSpeedTiers : DEFAULT_SPEED_TIERS.slice(),
+    defaultSpeedTier: normalizedDefaultSpeedTier
+  };
+}
+
+function normalizeReasoningEfforts(rawEfforts) {
+  if (!Array.isArray(rawEfforts)) {
+    return [];
+  }
+
+  const seen = new Set();
+  const result = [];
+  for (const rawEffort of rawEfforts) {
+    const effort = getString(typeof rawEffort === 'string' ? rawEffort : rawEffort?.effort);
+    if (!effort || seen.has(effort)) {
+      continue;
+    }
+    seen.add(effort);
+    result.push(effort);
+  }
+  return result;
+}
+
+function normalizeSpeedTiers(rawTiers) {
+  const tiers = ['standard'];
+  if (!Array.isArray(rawTiers)) {
+    return tiers;
+  }
+
+  for (const rawTier of rawTiers) {
+    const tier = getString(typeof rawTier === 'string' ? rawTier : rawTier?.tier || rawTier?.id || rawTier?.name);
+    if (tier && tier !== 'standard' && !tiers.includes(tier)) {
+      tiers.push(tier);
+    }
+  }
+  return tiers;
+}
+
+function buildFallbackModels() {
+  return FALLBACK_MODELS.map(model => buildModelEntry({
+    id: model.id,
+    label: model.label,
+    reasoningEfforts: DEFAULT_REASONING_EFFORTS,
+    defaultReasoningEffort: 'medium',
+    speedTiers: DEFAULT_SPEED_TIERS,
+    defaultSpeedTier: 'standard'
+  }));
+}
+
+function getString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+module.exports = {
+  resolveCodexModels
+};

package/native-host/src/codexPrompt.js

@@ -0,0 +1,192 @@
+'use strict';
+
+function buildCodexPrompt(request) {
+  const project = request.project || {};
+  const files = Array.isArray(project.files) ? project.files : [];
+  const focusFiles = normalizeFocusFiles(request.focusFiles || request.session?.focusFiles);
+  const orderedFiles = orderFilesByFocus(files, focusFiles);
+  const inventory = orderedFiles.map(file => `- ${file.path} (${String(file.content || '').length} chars)`).join('\n') || '- no files supplied';
+
+  return [
+    'You are generating edit operations for an Overleaf project.',
+    '',
+    `Mode: ${request.mode}`,
+    `Model: ${request.model || 'default'}`,
+    `Reasoning effort: ${request.reasoningEffort || 'default'}`,
+    `Session: ${request.session?.id || 'none'}`,
+    `Task: ${request.task}`,
+    `Active file: ${project.activePath || 'unknown'}`,
+    '',
+    'Recent session history:',
+    formatSessionHistory(request.session?.history),
+    '',
+    'Focus files:',
+    formatFocusFiles(focusFiles, files),
+    '',
+    'Files:',
+    inventory,
+    '',
+    'Return JSON only. Do not include Markdown fences.',
+    'Set status to "completed", "requires_task_confirmation", or "delete_plan_required".',
+    'Return userReport as natural user-facing language for the Overleaf panel.',
+    'Never put raw JSON, schema, stdout, stderr, or implementation details in userReport.',
+    'Always include notes as one concise user-facing sentence summarizing what changed or what was checked. For analysis-only or check-only tasks, set operations to [] and put concise findings in notes.',
+    'During the run, write short user-facing progress messages that say what you are checking, what you found, and what you will do next. Do not expose hidden chain-of-thought.',
+    'For Ask Mode, do not propose or return write operations. Return operations as [] and use notes for findings, explanations, and suggested next steps.',
+    'For userReport, include conclusion, checked files, findings, planned changes, applied changes, unchanged reason, and next step.',
+    'The schema is strict: every operation must include type, path, to, find, replace, replaceAll, content, and reason; use null for unused fields.',
+    'Use only these operation types:',
+    '- edit: { "type": "edit", "path": "...", "find": "...", "replace": "..." }',
+    '- edit replace all: { "type": "edit", "path": "...", "replaceAll": "..." }',
+    '- create: { "type": "create", "path": "...", "content": "..." }',
+    '- rename: { "type": "rename", "path": "...", "to": "..." }',
+    '- move: { "type": "move", "path": "...", "to": "..." }',
+    '- delete: { "type": "delete", "path": "...", "reason": "..." }',
+    '',
+    'Do not invent files that are not needed. Prefer minimal find/replace edits over replaceAll.',
+    'When focus files are provided, treat them as the primary context for reasoning and edits. Use other project files only when the task requires cross-file consistency, references, imports, or compilation context.',
+    'For Ask Mode, focus files still guide analysis, but never write.',
+    'For Confirm Mode, operations may include deletes because the user confirms the whole task summary before application.',
+    'For Auto Mode, deletes will be paused and confirmed separately by the bridge.',
+    '',
+    'Project file contents:',
+    ...orderedFiles.map(file => [
+      `--- FILE: ${file.path} ---`,
+      String(file.content || ''),
+      `--- END FILE: ${file.path} ---`
+    ].join('\n'))
+  ].join('\n');
+}
+
+function normalizeFocusFiles(value) {
+  const seen = new Set();
+  const files = [];
+  for (const item of Array.isArray(value) ? value : []) {
+    if (typeof item !== 'string') {
+      continue;
+    }
+    const path = item.trim();
+    if (!path || seen.has(path)) {
+      continue;
+    }
+    seen.add(path);
+    files.push(path);
+  }
+  return files.slice(0, 5);
+}
+
+function formatFocusFiles(focusFiles, files) {
+  if (!focusFiles.length) {
+    return '- none (default to whole project)';
+  }
+
+  const fileByPath = new Map(files.map(file => [file.path, file]));
+  return focusFiles.map(path => {
+    const file = fileByPath.get(path);
+    if (!file) {
+      return `- ${path} (primary context, not present in current snapshot)`;
+    }
+    return `- ${path} (primary context, ${String(file.content || '').length} chars)`;
+  }).join('\n');
+}
+
+function orderFilesByFocus(files, focusFiles) {
+  const focusSet = new Set(focusFiles);
+  return [...files].sort((left, right) => {
+    const leftFocus = focusSet.has(left.path);
+    const rightFocus = focusSet.has(right.path);
+    if (leftFocus !== rightFocus) {
+      return leftFocus ? -1 : 1;
+    }
+    return String(left.path || '').localeCompare(String(right.path || ''));
+  });
+}
+
+function formatSessionHistory(history) {
+  if (!Array.isArray(history) || history.length === 0) {
+    return '- none';
+  }
+
+  return history.slice(-8).map((item, index) => {
+    const task = item.task || 'untitled task';
+    const result = item.result || item.status || 'no result recorded';
+    return `${index + 1}. ${task}: ${result}`;
+  }).join('\n');
+}
+
+function buildOutputSchema() {
+  return {
+    type: 'object',
+    additionalProperties: false,
+    required: ['status', 'operations', 'notes', 'userReport'],
+    properties: {
+      status: {
+        type: 'string',
+        enum: ['requires_task_confirmation', 'completed', 'delete_plan_required']
+      },
+      notes: {
+        type: 'string'
+      },
+      userReport: {
+        type: 'object',
+        additionalProperties: false,
+        required: [
+          'conclusion',
+          'checked',
+          'findings',
+          'plannedChanges',
+          'appliedChanges',
+          'unchangedReason',
+          'nextStep'
+        ],
+        properties: {
+          conclusion: { type: 'string' },
+          checked: {
+            type: 'array',
+            items: { type: 'string' }
+          },
+          findings: {
+            type: 'array',
+            items: { type: 'string' }
+          },
+          plannedChanges: {
+            type: 'array',
+            items: { type: 'string' }
+          },
+          appliedChanges: {
+            type: 'array',
+            items: { type: 'string' }
+          },
+          unchangedReason: { type: 'string' },
+          nextStep: { type: 'string' }
+        }
+      },
+      operations: {
+        type: 'array',
+        items: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['type', 'path', 'to', 'find', 'replace', 'replaceAll', 'content', 'reason'],
+          properties: {
+            type: {
+              type: 'string',
+              enum: ['edit', 'create', 'rename', 'move', 'delete']
+            },
+            path: { type: 'string' },
+            to: { type: ['string', 'null'] },
+            find: { type: ['string', 'null'] },
+            replace: { type: ['string', 'null'] },
+            replaceAll: { type: ['string', 'null'] },
+            content: { type: ['string', 'null'] },
+            reason: { type: ['string', 'null'] }
+          }
+        }
+      }
+    }
+  };
+}
+
+module.exports = {
+  buildCodexPrompt,
+  buildOutputSchema
+};