Add also information about CODECHECKs via the plugin

[nuest]

CODECHECK is a community and approach for independent execution of computations underlying research articles as part of a peer review process.

We have a register of all checks: https://codecheck.org.uk/register

There also is a JSON representation of the data in the register: https://codecheck.org.uk/register/register.json I would probably fetch this only once per day (currently no search or pagination for this data, we could add an API endpoint for each publication for more targeted queries, but that may result in many many queries so just downloading the full register and caching it for some time seems to be a better way to go)

This could be used to show if a record in the Zotero database has a corresponding CODECHECK Certificate.

We could develop a separate plugin, but that seems unreasonable - would you welcome this as a feature?

[nuest]

AFAIK there is no curated open database for reproductions. https://scigen.report/ is not available anymore, it could have been on it's way there (e.g., https://web.archive.org/web/20221205050622/https://scigen.report/reviews/get/?doi=10.1063/1.1823034)

I also don't feel like it is a good idea to just add them, for example based on curated lists (see below), to the CODECHECK Register, BUT one could have a curated workflow and also query reproductions from Wikidata. Here are a few types that could be starting points:

• Reproducibility Report - Wikidata > https://www.wikidata.org/wiki/Q116740071
• CODECHECK - Wikidata > https://www.wikidata.org/wiki/Q116740091
  • https://w.wiki/GHPC

Lists of reproductions:

• CompRep: A Dataset For Computational Reproducibility | Proceedings of the 3rd ACM Conference on Reproducibility and Replicability > https://dl.acm.org/doi/10.1145/3736731.3746160
• ... (tbc.)

[nuest]

I've created a first version in a branch in my fork: https://github.com/nuest/fred_zotero/tree/codecheck-register

Next things to consider/to do:

• Review all code
• Discuss whether to use generic "Reproductions" vs. "CODECHECK", not only in UI but also in the codebase: how hard should I try to make "Reproduction" a generic and "CODECHECK" a specific implementation?
• How to improve the "Import to Collection" so that the PDF of the certificate is also retrieved; this is not trivial, basically OSF and Zenodo have to be queried for file listings and then the (first) PDF file has to be downloaded; maybe a direct file link in the register is more reasonable, the file discovery logic is already there but the URL is not exposed, it should be in the certificate details, e.g., https://codecheck.org.uk/register/certs/2020-001/index.json
• How to implement tests / UI tests ?

Full Implementation Plan by AI

CODECHECK Integration - Phase 1 Implementation Plan

Overview

Goal: Extend the plugin to discover CODECHECK certificates (reproductions) for research papers, using the same patterns as replications.

Terminology:

• User-facing: "Reproductions" (encompassing CODECHECK and potentially future sources)
• Internal/technical: "CODECHECK" for this specific data source

Key Design Decisions:

• Separate menu items from replications
• Notes-based display with on-demand certificate import via context menu
• DOI + arXiv ID matching
• Same read-only library handling pattern
• Auto-check configurable per data source
• No ban/blacklist feature for certificates
• Graceful failure for non-standard identifier formats

---

Data Sources

Register JSON

• URL: https://codecheck.org.uk/register/register.json
• Size: ~328 entries (small enough to cache fully)
• Refresh: Daily or on-demand

Certificate JSON (per entry)

• URL pattern: {Certificate Link}index.json
• Example: https://codecheck.org.uk/register/certs/2020-001/index.json
• Contains: Summary, codechecker ORCIDs, paper abstract, manifest

Certificate JSON Structure

{
  "certificate": {
    "id": "2020-001",
    "url": "https://codecheck.org.uk/register/certs/2020-001/"
  },
  "paper": {
    "title": "Paper Title",
    "authors": [{ "name": "Author Name" }],
    "reference": "https://doi.org/10.1093/example",
    "abstract": { "text": "...", "source": "CrossRef" }
  },
  "codecheck": {
    "codecheckers": [{ "name": "Name", "orcid": "0000-0001-8607-8025" }],
    "check_time": "2019-02-14 10:00:00",
    "repository": "github::codecheckers/example",
    "report": "http://doi.org/10.5281/zenodo.123456",
    "type": "journal",
    "venue": "GigaScience",
    "summary": "Description of what was checked and verified.",
    "manifest": [{ "file": "filename", "comment": "description" }]
  }
}

---

User Workflows & UI Extensions

1. Menu Items

Location	Menu Item Label	Action
Tools Menu	"Check Current Library for Reproductions"	Check all library items for CODECHECK certificates
Item Context Menu	"Check for Reproductions"	Check selected items for CODECHECK certificates
Collection Context Menu	"Check for Reproductions"	Check collection items for CODECHECK certificates
Help Menu	(extend existing guide)	Add reproduction/CODECHECK section

2. Tags

Tag	Purpose
Has Reproduction	Applied to papers with CODECHECK certificates
Reproduction Imported	Applied when certificate item is imported to collection
CODECHECK Certificate	Applied to imported certificate items
Original in Read-Only Library	(reuse existing tag for read-only handling)

3. Notes (Child of Paper)

Note Structure with Certificate Summary:

<h2>Reproduction Certificate(s) Found</h2>
<i>This is an automatically generated note. Do not make changes!</i>
<p>This study has an independent reproduction certificate from CODECHECK:</p>
<ul>
  <li>
    <strong>CODECHECK Certificate 2020-001</strong><br />
    <em>Check Date:</em> 2019-02-14<br />
    <em>Type:</em> Journal<br />
    <em>Venue:</em> GigaScience<br />
    <br />
    <strong>Summary:</strong><br />
    <blockquote>
      Only visualization steps performed, rather than machine learning (which
      could take several hours/days). The created figures match those in the
      article. The content of other output files was not checked.
    </blockquote>
    <br />
    <em>Codechecker(s):</em><br />
    • Stephen J. Eglen (<a href="https://orcid.org/0000-0001-8607-8025">ORCID</a
    >)<br />
    <br />
    <em>Report:</em>
    <a href="https://doi.org/10.5281/zenodo.3674056">10.5281/zenodo.3674056</a
    ><br />
    <em>Repository:</em>
    <a href="https://github.com/codecheckers/Piccolo-2020"
      >github::codecheckers/Piccolo-2020</a
    ><br />
    <em>Certificate:</em>
    <a href="https://codecheck.org.uk/register/certs/2020-001/"
      >View Certificate</a
    >
  </li>
</ul>
<hr />
<p>
  <small
    >Generated by Zotero Replication Checker using the CODECHECK Register (<a
      href="https://codecheck.org.uk"
      >codecheck.org.uk</a
    >)</small
  >
</p>

4. Certificate Import (Context Menu)

Trigger: Right-click on CODECHECK note → "Import CODECHECK Certificate to Collection"

Action:

1. Parse note to identify certificate ID
2. Create new Zotero item (type: report)
3. Populate fields:
   • Title: "CODECHECK Certificate {ID}: {Paper Title}"
   • Report Type: "CODECHECK Certificate"
   • URL: Certificate link
   • Date: Check date
   • Institution: "CODECHECK"
   • Abstract: Certificate summary
   • Extra: Report DOI, Repository link, Codechecker info
4. Add creators (codecheckers as "contributor" type with ORCIDs in Extra)
5. Add to same collection(s) as the original paper
6. Link as Related Item (bidirectional)
7. Add tag: CODECHECK Certificate
8. Add tag Reproduction Imported to original paper

5. Progress & Result Messages

Stage	Message
Headline	"Checking for Reproductions"
Scanning	"Scanning library for DOIs and arXiv IDs..."
Found	"Found {n} items with identifiers ({m} unique)"
Checking	"Checking against CODECHECK register..."
Fetching	"Fetching certificate details..."
Complete	"Found {n} item(s) with reproduction certificates"
Cache	"Using cached register (updated: {date}, {count} certificates)"
Error	"Could not fetch CODECHECK register - check your internet connection"

6. First-Run Prompt (After Replication Prompt)

The plugin can also check for reproduction certificates from CODECHECK -
independent code verification for research articles.

Would you like to scan your library for reproductions now?

• Click "Yes" to start scanning
• Click "No" to skip - you can scan later from Tools menu

7. Preferences Pane Extensions

New Settings Section:

┌─ Reproduction Checking (CODECHECK) ─────────────────────────┐
│                                                              │
│  ☑ Enable reproduction checking                             │
│                                                              │
│  Auto-check frequency: [Monthly ▼]                          │
│    Options: Disabled, Daily, Weekly, Monthly                │
│                                                              │
│  Cache status: 328 certificates                             │
│  Last updated: 2025-01-19 14:30                             │
│  [Refresh Cache Now]                                        │
│                                                              │
└──────────────────────────────────────────────────────────────┘

8. Read-Only Library Handling

When certificates are found for items in read-only group libraries:

Dialog:

Read-Only Library Detected

This library is read-only. We found {n} item(s) with {m} reproduction
certificate(s).

Would you like to copy the original articles to your Personal library
where reproduction information can be added?

Action (same as replications):

1. Copy original items to Personal library
2. Create "{Library Name} [Read-Only]" collection
3. Add notes with certificate information
4. Apply tags

---

Implementation Steps

Step 1: Identifier Extraction Utilities

File: src/utils/zoteroIntegration.ts

Add functions:

/**
 * Extract arXiv ID from item
 * Checks: URL field, Extra field, DOI field (for arXiv DOIs)
 * @returns arXiv ID (e.g., "2104.00718") or null
 */
export function extractArxivId(item: Zotero.Item): string | null;

/**
 * Get all items with identifiers from library
 * @returns Array of {itemID, doi?, arxivId?, title}
 */
export async function getAllIdentifiersFromLibrary(): Promise<
  ItemIdentifiers[]
>;

/**
 * Get all items with identifiers from collection
 */
export async function getIdentifiersFromCollection(
  collectionId: number,
): Promise<ItemIdentifiers[]>;

/**
 * Get identifiers from selected items
 */
export function getSelectedIdentifiers(): ItemIdentifiers[];

// Type definition
interface ItemIdentifiers {
  itemID: number;
  doi: string | null;
  arxivId: string | null;
  title: string;
}

Step 2: CODECHECK Data Source

New file: src/modules/codecheckDataSource.ts

/**
 * Represents a certificate entry from register.json
 */
interface RegisterEntry {
  certificateId: string;
  certificateLink: string;
  repository: string;
  repositoryLink: string;
  reportDoi: string;
  title: string;
  paperReference: string;
  type: string;
  venue: string;
  checkDate: string;
}

/**
 * Represents detailed certificate info from index.json
 */
interface CertificateDetails {
  id: string;
  url: string;
  summary: string;
  codecheckers: Array<{ name: string; orcid?: string }>;
  checkTime: string;
  repository: string;
  reportDoi: string;
  type: string;
  venue: string;
  manifest?: Array<{ file: string; comment: string }>;
  paperTitle: string;
  paperAuthors: Array<{ name: string }>;
  paperAbstract?: string;
}

/**
 * Cache structure stored in preferences
 */
interface CodecheckCache {
  lastUpdated: string;
  entries: RegisterEntry[];
}

/**
 * Runtime indexes for fast lookup
 */
interface CodecheckIndexes {
  doiIndex: Map<string, RegisterEntry[]>; // normalized DOI → entries
  arxivIndex: Map<string, RegisterEntry[]>; // arXiv ID → entries
}

export class CodecheckDataSource {
  private cache: CodecheckCache | null = null;
  private indexes: CodecheckIndexes | null = null;

  private readonly REGISTER_URL =
    "https://codecheck.org.uk/register/register.json";
  private readonly CACHE_PREF = "replication-checker.codecheckCache";
  private readonly CACHE_DATE_PREF = "replication-checker.codecheckCacheDate";
  private readonly CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours

  /**
   * Initialize data source - load from cache or fetch
   */
  async initialize(): Promise<void>;

  /**
   * Check if cache needs refresh (>24 hours old)
   */
  shouldRefreshCache(): boolean;

  /**
   * Fetch register.json and rebuild cache
   */
  async refreshCache(): Promise<void>;

  /**
   * Parse register.json into structured entries
   */
  private parseRegister(data: any[]): RegisterEntry[];

  /**
   * Build lookup indexes from entries
   */
  private buildIndexes(entries: RegisterEntry[]): CodecheckIndexes;

  /**
   * Extract DOI from paper reference URL
   * Handles: doi.org URLs, dx.doi.org, direct DOIs
   * @returns Normalized DOI or null
   */
  extractDoi(paperReference: string): string | null;

  /**
   * Extract arXiv ID from paper reference URL
   * Handles: arxiv.org/abs/*, arxiv.org/pdf/*
   * @returns arXiv ID (e.g., "2104.00718") or null
   */
  extractArxiv(paperReference: string): string | null;

  /**
   * Look up certificates by DOI
   * @returns Array of matching register entries
   */
  lookupByDoi(doi: string): RegisterEntry[];

  /**
   * Look up certificates by arXiv ID
   * @returns Array of matching register entries
   */
  lookupByArxiv(arxivId: string): RegisterEntry[];

  /**
   * Fetch detailed certificate info from index.json
   * @param certificateLink URL from register entry
   * @returns Full certificate details including summary and codecheckers
   */
  async fetchCertificateDetails(
    certificateLink: string,
  ): Promise<CertificateDetails | null>;

  /**
   * Get cache statistics
   */
  getCacheStats(): { count: number; lastUpdated: string | null };
}

Step 3: CODECHECK Checker Module

New file: src/modules/codecheckChecker.ts

import {
  CodecheckDataSource,
  RegisterEntry,
  CertificateDetails,
} from "./codecheckDataSource";
import * as ZoteroIntegration from "../utils/zoteroIntegration";
import { getString } from "../utils/strings";

interface CheckResult {
  itemID: number;
  doi: string | null;
  arxivId: string | null;
  certificates: RegisterEntry[];
}

export class CodecheckChecker {
  private dataSource: CodecheckDataSource;
  private rootURI: string = "";
  private autoCheckTimer: number | null = null;

  /**
   * Initialize the checker
   */
  async init(rootURI: string): Promise<void>;

  /**
   * Check entire library for CODECHECK certificates
   */
  async checkEntireLibrary(): Promise<void>;

  /**
   * Check selected items for CODECHECK certificates
   */
  async checkSelectedItems(): Promise<void>;

  /**
   * Check selected collection for CODECHECK certificates
   */
  async checkSelectedCollection(): Promise<void>;

  /**
   * Process check results - add tags and notes
   * @param results Items with matching certificates
   */
  private async processResults(results: CheckResult[]): Promise<void>;

  /**
   * Add certificate note to item
   * Fetches detailed certificate info and creates formatted note
   */
  private async addCertificateNote(
    itemID: number,
    entries: RegisterEntry[],
  ): Promise<void>;

  /**
   * Create HTML for certificate note
   */
  private createCertificateNoteHtml(details: CertificateDetails[]): string;

  /**
   * Format codecheckers with ORCID links
   */
  private formatCodecheckers(
    codecheckers: Array<{ name: string; orcid?: string }>,
  ): string;

  /**
   * Import certificate as Zotero item to collection
   * Called from context menu on CODECHECK notes
   */
  async importCertificateToCollection(
    paperItemID: number,
    certificateId: string,
  ): Promise<number>;

  /**
   * Handle items from read-only libraries
   * Same pattern as replicationChecker.handleReadOnlyLibrary()
   */
  private async handleReadOnlyLibrary(
    itemsWithCertificates: Map<number, RegisterEntry[]>,
    sourceLibraryID: number,
  ): Promise<void>;

  /**
   * Start auto-check timer based on preferences
   */
  private startAutoCheck(): void;

  /**
   * Stop auto-check timer
   */
  private stopAutoCheck(): void;

  /**
   * Get auto-check interval from preferences
   */
  private getAutoCheckInterval(): number;

  /**
   * Shutdown - cleanup timers and resources
   */
  shutdown(): void;
}

// Export singleton
export const codecheckChecker = new CodecheckChecker();

Step 4: Context Menu for Certificate Import

Extend: src/hooks.ts

// Register context menu for CODECHECK notes
ztoolkit.Menu.register("item", {
  tag: "menuitem",
  id: "codecheck-import-certificate",
  label: getString("codecheck-context-menu-import"),
  icon: `chrome://${config.addonRef}/content/icons/codecheck.png`,
  getVisibility: (elem, ev) => {
    // Only show for notes that are CODECHECK certificate notes
    const selectedItems = Zotero.getActiveZoteroPane().getSelectedItems();
    if (selectedItems.length !== 1) return false;
    const item = selectedItems[0];
    if (!item.isNote()) return false;
    const noteContent = item.getNote();
    return (
      noteContent.includes("CODECHECK Certificate") &&
      noteContent.includes("Reproduction Certificate")
    );
  },
  commandListener: async () => {
    const selectedItems = Zotero.getActiveZoteroPane().getSelectedItems();
    if (selectedItems.length !== 1) return;
    const noteItem = selectedItems[0];

    // Parse certificate ID from note
    const noteContent = noteItem.getNote();
    const match = noteContent.match(/CODECHECK Certificate (\d{4}-\d{3})/);
    if (!match) return;

    const certificateId = match[1];
    const parentItem = noteItem.parentItem;
    if (!parentItem) return;

    await codecheckChecker.importCertificateToCollection(
      parentItem.id,
      certificateId,
    );
  },
});

Step 5: Preferences Configuration

Extend: addon/prefs.js

// CODECHECK/Reproduction settings
pref("extensions.zotero.replication-checker.codecheckEnabled", true);
pref(
  "extensions.zotero.replication-checker.codecheckAutoCheckFrequency",
  "monthly",
);
pref("extensions.zotero.replication-checker.codecheckCacheDate", "");
pref("extensions.zotero.replication-checker.codecheckCache", "");

Extend: addon/content/preferences.xhtml

Add new section for reproduction/CODECHECK settings with:

• Enable/disable toggle
• Auto-check frequency dropdown
• Cache status display
• Refresh cache button

Step 6: Localization Strings

Extend: addon/locale/en-US/replication-checker.ftl

## Reproduction/CODECHECK Menu Items
codecheck-tools-menu = Check Current Library for Reproductions
codecheck-context-menu = Check for Reproductions
codecheck-context-menu-import = Import CODECHECK Certificate to Collection

## Reproduction Progress Messages
codecheck-progress-checking = Checking for Reproductions
codecheck-progress-scanning = Scanning library for DOIs and arXiv IDs...
codecheck-progress-found-ids = Found { $itemCount } items with identifiers ({ $uniqueCount } unique)
codecheck-progress-checking-register = Checking against CODECHECK register...
codecheck-progress-fetching-details = Fetching certificate details...
codecheck-progress-complete = Reproduction Check Complete
codecheck-progress-failed = Reproduction Check Failed
codecheck-progress-match-count = Found { $count } item(s) with reproduction certificates
codecheck-progress-cache-status = Using cached register (updated: { $date }, { $count } certificates)
codecheck-progress-copying-readonly = Copying items from read-only library...

## Reproduction Alerts
codecheck-alert-title = Reproduction Checker
codecheck-alert-no-ids = No DOIs or arXiv IDs found in selected items.
codecheck-error-title = Reproduction Checker - Error
codecheck-error-fetch = Could not fetch CODECHECK register - check your internet connection.
codecheck-error-details = Could not fetch certificate details for { $id }.

## Reproduction Tags
codecheck-tag = Has Reproduction
codecheck-tag-imported = Reproduction Imported
codecheck-tag-certificate = CODECHECK Certificate

## Reproduction Note Template
codecheck-note-title = Reproduction Certificate(s) Found
codecheck-note-warning = This is an automatically generated note. Do not make changes!
codecheck-note-intro = This study has an independent reproduction certificate from CODECHECK:
codecheck-note-summary-label = Summary:
codecheck-note-codecheckers-label = Codechecker(s):
codecheck-note-report-label = Report:
codecheck-note-repository-label = Repository:
codecheck-note-certificate-label = Certificate:
codecheck-note-view-certificate = View Certificate
codecheck-note-footer = Generated by Zotero Replication Checker using the CODECHECK Register
codecheck-note-codecheck-link = codecheck.org.uk

## Reproduction Results
codecheck-results-title = Reproduction Check Complete
codecheck-results-total = Total items checked: { $count }
codecheck-results-with-ids = Items with DOIs/arXiv IDs: { $count }
codecheck-results-found = { $count } item(s) have reproduction certificates.
codecheck-results-none = No reproduction certificates found.
codecheck-results-footer = Right-click on certificate notes to import to collection.

## Reproduction First Run
codecheck-prompt-title = Reproduction Checking
codecheck-prompt-first-run =
    The plugin can also check for reproduction certificates from CODECHECK -
    independent code verification for research articles.

    Would you like to scan your library for reproductions now?

    • Click "Yes" to start scanning
    • Click "No" to skip - you can scan later from Tools menu

## Read-Only Library (Reproductions)
codecheck-readonly-dialog-title = Read-Only Library Detected
codecheck-readonly-dialog-message =
    This library is read-only. We found { $itemCount } item(s) with { $certCount } reproduction certificate(s).

    Would you like to copy the original articles to your Personal library where reproduction information can be added?

## Reproduction Preferences
codecheck-prefs-section = Reproduction Checking (CODECHECK)
codecheck-prefs-enable = Enable reproduction checking
codecheck-prefs-auto-frequency = Auto-check frequency
codecheck-prefs-auto-disabled = Disabled
codecheck-prefs-auto-daily = Daily
codecheck-prefs-auto-weekly = Weekly
codecheck-prefs-auto-monthly = Monthly
codecheck-prefs-cache-status = Cache status: { $count } certificates
codecheck-prefs-cache-updated = Last updated: { $date }
codecheck-prefs-refresh-cache = Refresh Cache Now

## Certificate Import
codecheck-import-success = CODECHECK Certificate imported to collection.
codecheck-import-progress = Importing CODECHECK Certificate...

Step 7: Types Definition

Extend or create: src/types/codecheck.ts

/**
 * Register entry from register.json
 */
export interface CodecheckRegisterEntry {
  certificateId: string;
  certificateLink: string;
  repository: string;
  repositoryLink: string;
  reportDoi: string;
  title: string;
  paperReference: string;
  type: "journal" | "community" | "conference" | "institution" | "preprint";
  venue: string;
  checkDate: string;
}

/**
 * Codechecker info from certificate index.json
 */
export interface Codechecker {
  name: string;
  orcid?: string;
}

/**
 * Detailed certificate from index.json
 */
export interface CodecheckCertificateDetails {
  id: string;
  url: string;
  summary: string;
  codecheckers: Codechecker[];
  checkTime: string;
  repository: string;
  reportDoi: string;
  type: string;
  venue: string;
  manifest?: Array<{ file: string; comment: string }>;
  paper: {
    title: string;
    authors: Array<{ name: string }>;
    reference: string;
    abstract?: string;
  };
}

/**
 * Cache structure
 */
export interface CodecheckCache {
  lastUpdated: string;
  entries: CodecheckRegisterEntry[];
}

/**
 * Item identifiers for matching
 */
export interface ItemIdentifiers {
  itemID: number;
  doi: string | null;
  arxivId: string | null;
  title: string;
}

/**
 * Check result for an item
 */
export interface CodecheckResult {
  itemID: number;
  identifiers: ItemIdentifiers;
  certificates: CodecheckRegisterEntry[];
}

Step 8: Hook Integration

Extend: src/hooks.ts

import { codecheckChecker } from "./modules/codecheckChecker";

// In onStartup():
// Initialize CODECHECK checker
await codecheckChecker.init(rootURI);
Zotero.debug("[ReplicationChecker] CODECHECK checker initialized");

// Expose globally for context menu access
(Zotero as any).ReplicationChecker.codecheckChecker = codecheckChecker;

// In onMainWindowLoad():
// Register CODECHECK menu items
ztoolkit.Menu.register("menuTools", {
  tag: "menuitem",
  id: "codecheck-tools-menu",
  label: getString("codecheck-tools-menu"),
  icon: `chrome://${config.addonRef}/content/icons/favicon.png`,
  commandListener: () => codecheckChecker.checkEntireLibrary(),
});

ztoolkit.Menu.register("item", {
  tag: "menuitem",
  id: "codecheck-item-menu",
  label: getString("codecheck-context-menu"),
  icon: `chrome://${config.addonRef}/content/icons/favicon.png`,
  commandListener: () => codecheckChecker.checkSelectedItems(),
});

ztoolkit.Menu.register("collection", {
  tag: "menuitem",
  id: "codecheck-collection-menu",
  label: getString("codecheck-context-menu"),
  icon: `chrome://${config.addonRef}/content/icons/favicon.png`,
  commandListener: () => codecheckChecker.checkSelectedCollection(),
});

// Register certificate import context menu (see Step 4)

// In onShutdown():
codecheckChecker.shutdown();

Step 9: First-Run Integration

Extend: src/hooks.ts (onMainWindowLoad first-run section)

After replication first-run prompt, add CODECHECK prompt:

// After replication first-run handling...

// Check for CODECHECK first-run
const codecheckFirstRun = Zotero.Prefs.get(
  "replication-checker.codecheckFirstRunDone",
);
if (!codecheckFirstRun) {
  Zotero.Prefs.set("replication-checker.codecheckFirstRunDone", true);

  const ps = Services.prompt as any;
  const result = ps.confirmEx(
    promptWin as any,
    getString("codecheck-prompt-title"),
    getString("codecheck-prompt-first-run"),
    ps.BUTTON_POS_0 * ps.BUTTON_TITLE_YES +
      ps.BUTTON_POS_1 * ps.BUTTON_TITLE_NO,
    null,
    null,
    null,
    null,
    {},
  );

  if (result === 0) {
    Zotero.debug("[ReplicationChecker] User accepted CODECHECK first-run scan");
    codecheckChecker.checkEntireLibrary();
  }
}

---

File Structure Summary

src/
├── modules/
│   ├── replicationChecker.ts      # Existing
│   ├── codecheckChecker.ts        # NEW: Main CODECHECK logic
│   ├── codecheckDataSource.ts     # NEW: Register fetching & caching
│   ├── batchMatcher.ts            # Existing (replications)
│   ├── dataSource.ts              # Existing (replications)
│   ├── blacklistManager.ts        # Existing (replications only)
│   └── onboarding.ts              # EXTEND: Add reproduction info
├── utils/
│   ├── zoteroIntegration.ts       # EXTEND: Add arXiv extraction
│   ├── strings.ts                 # Existing
│   └── ztoolkit.ts                # Existing
├── types/
│   ├── replication.ts             # Existing
│   └── codecheck.ts               # NEW: CODECHECK types
├── hooks.ts                       # EXTEND: CODECHECK menus & init
├── addon.ts                       # Existing
└── index.ts                       # Existing

addon/
├── content/
│   ├── preferences.xhtml          # EXTEND: CODECHECK settings
│   ├── onboarding.xhtml           # EXTEND: Reproduction info
│   └── icons/
│       └── (existing icons)
├── locale/
│   ├── en-US/
│   │   └── replication-checker.ftl  # EXTEND: codecheck-* strings
│   └── de/
│       └── replication-checker.ftl  # EXTEND: German translations
├── bootstrap.js                   # Existing
├── manifest.json                  # Existing
└── prefs.js                       # EXTEND: CODECHECK prefs

---

Identifier Parsing Rules

DOI Extraction from Paper Reference

function extractDoi(paperReference: string): string | null {
  if (!paperReference) return null;

  const normalized = paperReference.trim().toLowerCase();

  // Pattern 1: https://doi.org/10.xxxx/yyyy
  // Pattern 2: http://dx.doi.org/10.xxxx/yyyy
  // Pattern 3: doi:10.xxxx/yyyy
  const doiPatterns = [
    /(?:https?:\/\/)?(?:dx\.)?doi\.org\/(.+)/i,
    /^doi:\s*(.+)/i,
    /\b(10\.\d{4,}\/[^\s]+)/i,
  ];

  for (const pattern of doiPatterns) {
    const match = normalized.match(pattern);
    if (match) {
      return match[1].replace(/\/$/, ""); // Remove trailing slash
    }
  }

  return null;
}

arXiv ID Extraction

function extractArxiv(paperReference: string): string | null {
  if (!paperReference) return null;

  // Pattern 1: https://arxiv.org/abs/2104.00718
  // Pattern 2: https://arxiv.org/pdf/2104.00718.pdf
  // Pattern 3: arXiv:2104.00718
  const arxivPatterns = [
    /arxiv\.org\/(?:abs|pdf)\/(\d{4}\.\d{4,5})/i,
    /arxiv:(\d{4}\.\d{4,5})/i,
    /\b(\d{4}\.\d{4,5})v?\d*\b/, // Just the ID with optional version
  ];

  for (const pattern of arxivPatterns) {
    const match = paperReference.match(pattern);
    if (match) {
      return match[1];
    }
  }

  return null;
}

Graceful Failure Handling

// When parsing fails, log and continue
try {
  const doi = extractDoi(entry.paperReference);
  const arxiv = extractArxiv(entry.paperReference);

  if (!doi && !arxiv) {
    Zotero.debug(
      `[CODECHECK] Could not extract identifier from: ${entry.paperReference}`,
    );
    // Still include in cache, just won't match
  }
} catch (error) {
  Zotero.debug(`[CODECHECK] Parse error for ${entry.certificateId}: ${error}`);
  // Continue processing other entries
}

---

Testing Checklist

Unit Tests

• DOI extraction from various URL formats
• arXiv ID extraction from various URL formats
• Cache serialization/deserialization
• Index building and lookup

Integration Tests

• Register fetching and parsing
• Certificate details fetching
• Note creation with summary and codecheckers
• Certificate import to collection
• Read-only library handling
• Auto-check timer functionality

Manual Tests

• Tools menu → Check Library for Reproductions
• Item context menu → Check for Reproductions
• Collection context menu → Check for Reproductions
• Note context menu → Import Certificate
• Preferences → Enable/disable reproduction checking
• Preferences → Change auto-check frequency
• Preferences → Refresh cache
• First-run prompt after fresh install
• Read-only group library handling

---

Future Considerations

1. Combined Check Option: Future version could add "Check for All Reproducibility Info" that runs both replication and CODECHECK checks together.

2. Additional Data Sources: The "Reproductions" terminology allows adding more sources (e.g., Wikidata reproducibility entries, CompRep dataset) without renaming.

3. API Integration: If CODECHECK adds a lookup API (issue #150), could switch from caching to real-time queries.

4. Statistics Dashboard: Show summary of reproductions found across library.

[LukasWallrich]

@nuest thanks for this! There is indeed no database of reproductions, but we are planning to integrate them into the FLoRA database. So we might not retrieve codecheck separately in this plugin (though we'd want to label CODECHECK results as such in Zotero).

The data extraction itself would rather happen as part of the dataset creation in https://github.com/forrtproject/FReD-data. We will have a look at your code soon and then propose a workflow - and then we can maybe meet to discuss

[nuest]

Sounds good. I'm happy when reproductions/checks appear in Zenodo with the Plugin, if it comes from another online service/API that is fine. I'd be happy nevertheless if it is possible to contribute the "PDF retrieval" feature for CODECHECKs specifically.

The changes: main...nuest:fred_zotero:codecheck-register