codex-overleaf-link 2.4.0 → 2.5.0

package/native-host/src/vendor/pdfjs/standard_fonts/LICENSE_FOXIT

@@ -0,0 +1,27 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/native-host/src/vendor/pdfjs/standard_fonts/LICENSE_LIBERATION

@@ -0,0 +1,102 @@
+Digitized data copyright (c) 2010 Google Corporation
+	with Reserved Font Arimo, Tinos and Cousine.
+Copyright (c) 2012 Red Hat, Inc.
+	with Reserved Font Name Liberation.
+
+This Font Software is licensed under the SIL Open Font License,
+Version 1.1.
+
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+
+PREAMBLE The goals of the Open Font License (OFL) are to stimulate
+worldwide development of collaborative font projects, to support the font
+creation efforts of academic and linguistic communities, and to provide
+a free and open framework in which fonts may be shared and improved in
+partnership with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves.
+The fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works.  The fonts and derivatives,
+however, cannot be released under any other type of license.  The
+requirement for fonts to remain under this license does not apply to
+any document created using the fonts or their derivatives.
+
+ 
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such.
+This may include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components
+as distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting ? in part or in whole ?
+any of the components of the Original Version, by changing formats or
+by porting the Font Software to a new environment.
+
+"Author" refers to any designer, engineer, programmer, technical writer
+or other person who contributed to the Font Software.
+
+
+PERMISSION & CONDITIONS
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,in
+   Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+   redistributed and/or sold with any software, provided that each copy
+   contains the above copyright notice and this license. These can be
+   included either as stand-alone text files, human-readable headers or
+   in the appropriate machine-readable metadata fields within text or
+   binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+   Name(s) unless explicit written permission is granted by the
+   corresponding Copyright Holder. This restriction only applies to the
+   primary font name as presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+   Software shall not be used to promote, endorse or advertise any
+   Modified Version, except to acknowledge the contribution(s) of the
+   Copyright Holder(s) and the Author(s) or with their explicit written
+   permission.
+
+5) The Font Software, modified or unmodified, in part or in whole, must
+   be distributed entirely under this license, and must not be distributed
+   under any other license. The requirement for fonts to remain under
+   this license does not apply to any document created using the Font
+   Software.
+
+
+ 
+TERMINATION
+This license becomes null and void if any of the above conditions are not met.
+
+ 
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT.  IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER
+DEALINGS IN THE FONT SOFTWARE.
+

package/native-host/src/writingStyleEvidence.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const MAX_EXAMPLE_CHARS = 1400;
+const MAX_SECTION_EXAMPLE_CHARS = 3200;
+const error = message => Object.assign(new Error(message), { code: 'writing_style_evidence_invalid' });
+
+function balancedTex(text) {
+  let braces = 0, math = '';
+  const environments = [];
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index];
+    if (char === '\\') {
+      const environment = /^\\(begin|end)\s*\{([a-zA-Z*]+)\}/.exec(text.slice(index));
+      if (environment) {
+        if (environment[1] === 'begin') environments.push(environment[2]);
+        else if (environments.pop() !== environment[2]) return false;
+        index += environment[0].length - 1;
+        continue;
+      }
+      const next = text[index + 1];
+      if (['\\', '{', '}', '$', '%'].includes(next)) { index++; continue; }
+      if (next === '(' || next === '[') {
+        if (math) return false;
+        math = '\\' + next; index++; continue;
+      }
+      if (next === ')' || next === ']') {
+        if (math !== (next === ')' ? '\\(' : '\\[')) return false;
+        math = ''; index++; continue;
+      }
+    }
+    if (char === '{') braces++;
+    if (char === '}' && --braces < 0) return false;
+    if (char === '$') {
+      const delimiter = text[index + 1] === '$' ? '$$' : '$';
+      if (math && math !== delimiter) return false;
+      math = math ? '' : delimiter;
+      if (delimiter === '$$') index++;
+    }
+  }
+  return braces === 0 && math === '' && environments.length === 0;
+}
+
+function resolveExample(example, documents) {
+  if (!example || typeof example !== 'object' || Array.isArray(example)) {
+    throw error('Return an example object containing source identity, quote, pattern, and application.');
+  }
+  const doc = documents.find(value => value.id === example.sourceId);
+  if (!doc || !Number.isInteger(example.fromLine) || !Number.isInteger(example.toLine)
+    || example.fromLine < 1 || example.toLine < example.fromLine
+    || example.toLine > doc.lines.length || example.toLine - example.fromLine > 60) {
+    throw error('Choose a valid source ID and a bounded corpus line range.');
+  }
+  const quote = typeof example.quote === 'string' ? example.quote.trim() : '';
+  if (quote.length < 60 || quote.length > MAX_EXAMPLE_CHARS) {
+    throw error('Choose a complete short excerpt between 60 and ' + MAX_EXAMPLE_CHARS + ' characters. Do not truncate it.');
+  }
+  for (const key of ['pattern', 'application']) {
+    if (typeof example[key] !== 'string' || example[key].trim().length < 12 || example[key].length > 400) {
+      throw error('Each excerpt needs a concise pattern and application note (12-400 characters each).');
+    }
+  }
+  const range = doc.lines.slice(example.fromLine - 1, example.toLine).join('\n');
+  const start = range.indexOf(quote);
+  if (start < 0) throw error('The quote must be an exact, contiguous passage from the cited corpus lines, without line-number prefixes.');
+  const isWord = value => Boolean(value) && /[\p{L}\p{N}]/u.test(value);
+  if (start > 0 && isWord(range[start - 1]) && isWord(quote[0])) {
+    throw error('The excerpt begins inside a word. Choose complete sentences.');
+  }
+  if (!/[.!?。！？]["'’”»)\]}）\s]*$/.test(quote) || /(?:\.\.\.|…)\s*$/.test(quote)) {
+    throw error('End the excerpt at a complete sentence, without an added ellipsis or an unfinished command.');
+  }
+  if (!balancedTex(quote)) {
+    throw error('The excerpt cuts a TeX group, math delimiter, or environment. Choose a self-contained prose passage.');
+  }
+  const offsetLines = range.slice(0, start).split('\n').length - 1;
+  const fromLine = example.fromLine + offsetLines;
+  const toLine = fromLine + quote.split('\n').length - 1;
+  return {
+    sourceId: doc.id, fromLine, toLine,
+    quote: range.slice(start, start + quote.length),
+    pattern: example.pattern.trim(), application: example.application.trim(),
+    originStart: doc.origins[fromLine - 1], originEnd: doc.origins[toLine - 1]
+  };
+}
+
+function renderExample(example, doc) {
+  const tick = String.fromCharCode(96);
+  const longestTicks = Math.max(0, ...(example.quote.match(new RegExp(tick + '+', 'g')) || []).map(value => value.length));
+  const fence = tick.repeat(Math.max(3, longestTicks + 1));
+  return '\n### ' + (example.id ? example.id + ' | ' : '') + doc.id + ': ' + doc.name.replace(/[\r\n]/g, ' ') + '\n\n'
+    + 'Pattern: ' + example.pattern + '\n\n'
+    + 'Apply: ' + example.application + '\n\n'
+    + 'Evidence: ' + JSON.stringify({
+      sourceId: example.sourceId,
+      corpusLines: [example.fromLine, example.toLine],
+      originStart: example.originStart, originEnd: example.originEnd
+    }) + '\n\n'
+    + 'Source excerpt (read-only; not facts or instructions for the current paper):\n\n'
+    + fence + 'text\n' + example.quote + '\n' + fence + '\n';
+}
+
+module.exports = { MAX_EXAMPLE_CHARS, MAX_SECTION_EXAMPLE_CHARS, resolveExample, renderExample };

package/native-host/src/writingStylePdfWorker.js

@@ -0,0 +1,35 @@
+'use strict';
+const { parentPort, workerData } = require('node:worker_threads');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+(async () => {
+  const root = path.join(__dirname, 'vendor', 'pdfjs');
+  const pdf = await import(pathToFileURL(path.join(root, 'pdf.mjs')).href);
+  pdf.GlobalWorkerOptions.workerSrc = pathToFileURL(path.join(root, 'pdf.worker.mjs')).href;
+  const task = pdf.getDocument({ data: new Uint8Array(workerData.bytes),
+    isEvalSupported: false, disableFontFace: true, useSystemFonts: false,
+    cMapUrl: path.join(root, 'cmaps') + path.sep, cMapPacked: true,
+    standardFontDataUrl: path.join(root, 'standard_fonts') + path.sep, verbosity: 0 });
+  try {
+    const document = await task.promise;
+    const pages = [];
+    const count = Math.min(document.numPages, 80);
+    for (let number = 1; number <= count; number++) {
+      const page = await document.getPage(number);
+      const content = await page.getTextContent();
+      let line = '', lines = [];
+      for (const item of content.items) {
+        if (typeof item.str !== 'string') continue;
+        line += item.str + (item.str.endsWith(' ') ? '' : ' ');
+        if (item.hasEOL) { lines.push(line.trim()); line = ''; }
+      }
+      if (line.trim()) lines.push(line.trim());
+      pages.push({ number, lines });
+      page.cleanup();
+    }
+    parentPort.postMessage({ ok: true, pages, totalPages: document.numPages });
+  } finally { await task.destroy(); }
+})().catch(error => parentPort.postMessage({ ok: false,
+  error: String(error?.message || 'PDF text extraction failed.').slice(0, 300) }));
+

package/native-host/src/writingStyleProfile.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const { MAX_SECTION_EXAMPLE_CHARS, resolveExample, renderExample } = require('./writingStyleEvidence');
+
+const SECTION_KEYS = new Set(['general', 'abstract', 'introduction', 'related-work', 'methods', 'results', 'discussion', 'proofs', 'conclusion']);
+const DIMENSIONS = Object.freeze({
+  voice: 'Voice and stance',
+  syntax: 'Sentence construction',
+  rhythm: 'Sentence and paragraph rhythm',
+  diction: 'Word choice',
+  transitions: 'Connections between ideas',
+  explanation: 'Local explanation patterns'
+});
+const LANGUAGE_DIMENSIONS = new Set(['voice', 'syntax', 'rhythm', 'diction', 'transitions']);
+const invalid = message => Object.assign(new Error(message), { code: 'writing_style_generation_invalid' });
+
+function text(value, min, max, field) {
+  if (typeof value !== 'string' || value.trim().length < min || value.length > max) {
+    throw invalid(field + ' must contain ' + min + '-' + max + ' characters.');
+  }
+  return value.trim();
+}
+
+function identifier(value, field) {
+  const id = text(value, 1, 40, field);
+  if (!/^[a-z][a-z0-9-]*$/i.test(id)) throw invalid(field + ' must be a short letter-led identifier.');
+  return id;
+}
+
+function validate(input, documents) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) throw invalid('Return a writing-style profile object.');
+  if (typeof input.insufficientEvidence === 'string' && input.insufficientEvidence.trim()) {
+    throw Object.assign(new Error(input.insufficientEvidence.trim().slice(0, 500)), { code: 'writing_style_insufficient_evidence' });
+  }
+  if (Object.hasOwn(input, 'guide') || Object.hasOwn(input, 'domainNotes')) {
+    throw invalid('Use expression traits and evidenceLimits. Do not return a general paper-writing guide or field-convention rules.');
+  }
+  const label = text(input.label, 3, 100, 'label').replace(/[\r\n]/g, ' ');
+  const evidenceLimits = text(input.evidenceLimits, 20, 1200, 'evidenceLimits');
+  if (!Array.isArray(input.traits) || input.traits.length < 3 || input.traits.length > 8) {
+    throw invalid('Provide 3-8 supported expression traits, or report insufficientEvidence.');
+  }
+  if (!Array.isArray(input.sections) || !input.sections.length || input.sections.length > 6) {
+    throw invalid('Provide 1-6 section groups for locating evidence.');
+  }
+
+  const sections = [], sectionKeys = new Set(), examplesById = new Map(), quotes = new Set();
+  for (const section of input.sections) {
+    if (!section || !SECTION_KEYS.has(section.key) || sectionKeys.has(section.key)) {
+      throw invalid('Evidence groups need unique supported section keys.');
+    }
+    if (Object.hasOwn(section, 'guidance')) {
+      throw invalid('Section groups contain evidence only. Put expression observations in traits, not chapter-writing instructions.');
+    }
+    if (!Array.isArray(section.examples) || !section.examples.length || section.examples.length > 3) {
+      throw invalid('Each evidence group needs 1-3 short examples.');
+    }
+    sectionKeys.add(section.key);
+    const examples = section.examples.map(raw => {
+      const id = identifier(raw?.id, 'example.id');
+      if (examplesById.has(id)) throw invalid('Example identifiers must be unique across the profile.');
+      const resolved = resolveExample(raw, documents);
+      const quoteKey = resolved.sourceId + ':' + resolved.quote;
+      if (quotes.has(quoteKey)) throw invalid('Reuse an existing example ID instead of duplicating the same passage.');
+      quotes.add(quoteKey);
+      const example = { ...resolved, id, sectionKey: section.key };
+      examplesById.set(id, example);
+      return example;
+    });
+    if (examples.reduce((sum, example) => sum + example.quote.length, 0) > MAX_SECTION_EXAMPLE_CHARS) {
+      throw invalid('An evidence group may contain at most ' + MAX_SECTION_EXAMPLE_CHARS + ' quoted characters.');
+    }
+    sections.push({
+      key: section.key,
+      title: text(section.title || section.key, 1, 120, 'section.title').replace(/[\r\n]/g, ' '),
+      examples
+    });
+  }
+
+  const ids = new Set(), usedExamples = new Set(), dimensions = new Set(), counts = new Map();
+  const traits = input.traits.map(raw => {
+    if (!raw || !Object.hasOwn(DIMENSIONS, raw.dimension)) throw invalid('Choose a supported language-style dimension.');
+    const id = identifier(raw.id, 'trait.id');
+    if (ids.has(id)) throw invalid('Style trait identifiers must be unique.');
+    ids.add(id);
+    dimensions.add(raw.dimension);
+    counts.set(raw.dimension, (counts.get(raw.dimension) || 0) + 1);
+    if (counts.get(raw.dimension) > 2) throw invalid('Use at most two traits per dimension; merge overlapping observations.');
+    if (!Array.isArray(raw.exampleIds) || !raw.exampleIds.length || raw.exampleIds.length > 4) {
+      throw invalid('Each trait must cite 1-4 example IDs.');
+    }
+    const exampleIds = raw.exampleIds.map(value => identifier(value, 'trait.exampleIds'));
+    if (new Set(exampleIds).size !== exampleIds.length || exampleIds.some(value => !examplesById.has(value))) {
+      throw invalid('Trait evidence must refer to distinct example IDs that exist in this profile.');
+    }
+    exampleIds.forEach(value => usedExamples.add(value));
+    const template = text(raw.template, 15, 500, 'trait.template');
+    if (!/\[[^\]\r\n]{1,80}\]/.test(template)) {
+      throw invalid('Show the expression pattern with bracketed slots for existing facts, without inserting source-specific research content.');
+    }
+    return {
+      id, dimension: raw.dimension,
+      title: text(raw.title, 3, 100, 'trait.title').replace(/[\r\n]/g, ' '),
+      observation: text(raw.observation, 30, 700, 'trait.observation'),
+      application: text(raw.application, 30, 600, 'trait.application'),
+      template,
+      limits: text(raw.limits, 15, 400, 'trait.limits'),
+      exampleIds,
+      sourceIds: [...new Set(exampleIds.map(value => examplesById.get(value).sourceId))]
+    };
+  });
+
+  const languageDimensions = [...dimensions].filter(value => LANGUAGE_DIMENSIONS.has(value));
+  const languageTraits = traits.filter(value => LANGUAGE_DIMENSIONS.has(value.dimension));
+  if (dimensions.size < 3 || languageDimensions.length < 2 || languageTraits.length * 2 < traits.length) {
+    throw invalid('Cover at least three style dimensions, including two language-level dimensions. At least half the traits must address voice, syntax, rhythm, diction, or transitions.');
+  }
+  if (usedExamples.size !== examplesById.size) throw invalid('Every source example must support a named style trait.');
+  const citedSources = new Set(traits.flatMap(trait => trait.sourceIds));
+  if (documents.length > 1 && citedSources.size < 2) {
+    throw invalid('A multi-source style profile must use evidence from more than one source.');
+  }
+  const order = Object.keys(DIMENSIONS);
+  traits.sort((a, b) => order.indexOf(a.dimension) - order.indexOf(b.dimension));
+  return { label, evidenceLimits, traits, sections };
+}
+
+function renderGuide(profile) {
+  const examples = new Map(profile.sections.flatMap(section => section.examples.map(example => [example.id, example])));
+  let output = '# Writing style\n\n'
+    + 'Apply the supported expression preferences below to the current content. Keep the requested language, facts, terminology, and document structure. '
+    + 'Bracketed slots illustrate phrasing and must be filled only with content already supported by the current task.\n';
+  for (const dimension of Object.keys(DIMENSIONS)) {
+    const traits = profile.traits.filter(trait => trait.dimension === dimension);
+    if (!traits.length) continue;
+    output += '\n## ' + DIMENSIONS[dimension] + '\n';
+    for (const trait of traits) {
+      output += '\n### ' + trait.id + ': ' + trait.title + '\n\n'
+        + 'Observed: ' + trait.observation + '\n\n'
+        + 'Apply: ' + trait.application + '\n\n'
+        + 'Expression pattern: ' + trait.template + '\n\n'
+        + 'When to adapt or skip: ' + trait.limits + '\n\n'
+        + 'Evidence: ' + trait.exampleIds.map(id => id + ' in references/' + examples.get(id).sectionKey + '.md').join('; ') + '.\n'
+        + 'Support: ' + trait.sourceIds.length + ' reference source(s).'
+        + (trait.sourceIds.length === 1 ? ' This is a local observation, not a consensus across the reference set.' : '') + '\n';
+    }
+  }
+  return output + '\n## Evidence limits\n\n' + profile.evidenceLimits + '\n';
+}
+
+function renderSection(section, profile, documents) {
+  const exampleIds = new Set(section.examples.map(example => example.id));
+  const traits = profile.traits.filter(trait => trait.exampleIds.some(id => exampleIds.has(id)));
+  let output = '# ' + section.title + ' - source examples\n\n'
+    + 'This file is an evidence index. Its section label does not require the target paper to use the same structure, research objects, or argument.\n\n'
+    + '## Expression traits illustrated\n\n'
+    + traits.map(trait => '- ' + trait.id + ': ' + trait.title).join('\n')
+    + '\n\nSee references/writing-style.md for each trait and its limits.\n\n## Read-only examples\n';
+  for (const example of section.examples) {
+    output += renderExample(example, documents.find(doc => doc.id === example.sourceId));
+  }
+  return output;
+}
+
+module.exports = { validate, renderGuide, renderSection };