docrev 0.11.3 → 0.12.0

package/lib/plugins.ts

@@ -1,362 +0,0 @@
-/**
- * Plugin system for custom journal profiles and export formats
- *
- * Users can add custom profiles in:
- * - Project: .rev/profiles/*.yaml
- * - User: ~/.rev/profiles/*.yaml
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import * as yaml from 'yaml';
-
-/**
- * Journal profile requirements
- */
-interface ProfileRequirements {
-  wordLimit?: Record<string, number | null>;
-  references?: Record<string, unknown>;
-  figures?: Record<string, unknown>;
-  sections?: Record<string, unknown>;
-  authors?: Record<string, unknown>;
-  keywords?: { min?: number; max?: number } | null;
-  dataAvailability?: boolean;
-  [key: string]: unknown;
-}
-
-/**
- * Journal profile
- */
-interface Profile {
-  id?: string;
-  name: string;
-  url?: string | null;
-  custom?: boolean;
-  requirements?: ProfileRequirements;
-  [key: string]: unknown;
-}
-
-/**
- * Journal formatting defaults
- */
-interface ProfileFormatting {
-  csl?: string;
-  pdf?: Record<string, unknown>;
-  docx?: Record<string, unknown>;
-  crossref?: Record<string, unknown>;
-  [key: string]: unknown;
-}
-
-/**
- * Normalized profile
- */
-interface NormalizedProfile {
-  name: string;
-  url: string | null;
-  custom: boolean;
-  requirements: ProfileRequirements;
-  formatting?: ProfileFormatting;
-}
-
-/**
- * Profile list entry
- */
-interface ProfileListEntry {
-  id: string;
-  name: string;
-  source: 'user' | 'project';
-  path: string;
-}
-
-/**
- * Plugin directories info
- */
-interface PluginDirsInfo {
-  user: string;
-  project: string;
-  userExists: boolean;
-  projectExists: boolean;
-}
-
-// Plugin directories
-const USER_PLUGINS_DIR = path.join(os.homedir(), '.rev', 'profiles');
-const PROJECT_PLUGINS_DIR = path.join(process.cwd(), '.rev', 'profiles');
-
-/**
- * Load all custom journal profiles
- */
-export function loadCustomProfiles(): Record<string, NormalizedProfile> {
-  const profiles: Record<string, NormalizedProfile> = {};
-
-  // Load user profiles first (lower priority)
-  const userProfiles = loadProfilesFromDir(USER_PLUGINS_DIR);
-  Object.assign(profiles, userProfiles);
-
-  // Load project profiles (higher priority, can override)
-  const projectProfiles = loadProfilesFromDir(PROJECT_PLUGINS_DIR);
-  Object.assign(profiles, projectProfiles);
-
-  return profiles;
-}
-
-/**
- * Load profiles from a directory
- */
-function loadProfilesFromDir(dir: string): Record<string, NormalizedProfile> {
-  const profiles: Record<string, NormalizedProfile> = {};
-
-  if (!fs.existsSync(dir)) {
-    return profiles;
-  }
-
-  try {
-    const files = fs.readdirSync(dir).filter(f =>
-      f.endsWith('.yaml') || f.endsWith('.yml') || f.endsWith('.json')
-    );
-
-    for (const file of files) {
-      try {
-        const filePath = path.join(dir, file);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const profile = file.endsWith('.json')
-          ? JSON.parse(content)
-          : yaml.parse(content);
-
-        if (validateProfile(profile)) {
-          const id = profile.id || path.basename(file, path.extname(file));
-          profiles[id] = normalizeProfile(profile);
-        }
-      } catch (err: unknown) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`Warning: Failed to load profile ${file}: ${message}`);
-      }
-    }
-  } catch {
-    // Directory not readable
-  }
-
-  return profiles;
-}
-
-/**
- * Validate a profile structure
- */
-function validateProfile(profile: unknown): profile is Profile {
-  if (!profile || typeof profile !== 'object') {
-    return false;
-  }
-
-  const p = profile as Profile;
-
-  // Must have a name
-  if (!p.name || typeof p.name !== 'string') {
-    return false;
-  }
-
-  // Requirements must be an object if present
-  if (p.requirements && typeof p.requirements !== 'object') {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Normalize profile to standard structure
- */
-function normalizeProfile(profile: Profile): NormalizedProfile {
-  const normalized: NormalizedProfile = {
-    name: profile.name,
-    url: profile.url || null,
-    custom: true,
-    requirements: {
-      wordLimit: profile.requirements?.wordLimit || (profile as { wordLimit?: Record<string, number> }).wordLimit || {},
-      references: profile.requirements?.references || (profile as { references?: Record<string, unknown> }).references || {},
-      figures: profile.requirements?.figures || (profile as { figures?: Record<string, unknown> }).figures || {},
-      sections: profile.requirements?.sections || (profile as { sections?: Record<string, unknown> }).sections || {},
-      authors: profile.requirements?.authors || (profile as { authors?: Record<string, unknown> }).authors || {},
-      keywords: profile.requirements?.keywords || (profile as { keywords?: { min?: number; max?: number } }).keywords || null,
-      dataAvailability: profile.requirements?.dataAvailability || (profile as { dataAvailability?: boolean }).dataAvailability || false,
-      ...profile.requirements,
-    },
-  };
-
-  // Pass through formatting if present
-  const formatting = (profile as { formatting?: ProfileFormatting }).formatting;
-  if (formatting && typeof formatting === 'object') {
-    normalized.formatting = formatting;
-  }
-
-  return normalized;
-}
-
-/**
- * Initialize plugin directories
- */
-export function initPluginDir(project = false): string {
-  const dir = project ? PROJECT_PLUGINS_DIR : USER_PLUGINS_DIR;
-
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-
-  return dir;
-}
-
-/**
- * Get plugin directories info
- */
-export function getPluginDirs(): PluginDirsInfo {
-  return {
-    user: USER_PLUGINS_DIR,
-    project: PROJECT_PLUGINS_DIR,
-    userExists: fs.existsSync(USER_PLUGINS_DIR),
-    projectExists: fs.existsSync(PROJECT_PLUGINS_DIR),
-  };
-}
-
-/**
- * Create a sample profile template
- */
-export function createProfileTemplate(journalName: string): string {
-  const id = journalName.toLowerCase().replace(/\s+/g, '-');
-
-  return `# Custom journal profile for ${journalName}
-# Save as: ~/.rev/profiles/${id}.yaml (user-wide)
-# Or: .rev/profiles/${id}.yaml (project-specific)
-
-id: ${id}
-name: "${journalName}"
-url: "https://journal-website.com/author-guidelines"
-
-# Word count limits
-wordLimit:
-  main: 8000      # null for no limit
-  abstract: 300
-  title: null     # characters
-
-# Reference requirements
-references:
-  max: null       # null for no limit
-  doiRequired: true
-
-# Figure/table limits
-figures:
-  max: 8
-  combinedWithTables: false
-
-# Required sections
-sections:
-  required:
-    - Abstract
-    - Introduction
-    - Methods
-    - Results
-    - Discussion
-  methodsPosition: null  # 'end' or 'before-results'
-
-# Keywords
-keywords:
-  min: 4
-  max: 8
-
-# Other requirements
-dataAvailability: true
-highlights: false
-graphicalAbstract: false
-
-# Build formatting defaults (applied via rev build -j ${id})
-# formatting:
-#   csl: "${id}"            # CSL style name or path
-#   pdf:
-#     fontsize: 12pt
-#     geometry: margin=1in
-#     linestretch: 1.5
-#     numbersections: false
-#   docx:
-#     reference: null       # Path to reference .docx template
-#   crossref:
-#     figPrefix: [Fig., Figs.]
-#     tblPrefix: [Table, Tables]
-`;
-}
-
-/**
- * Save a profile template
- */
-export function saveProfileTemplate(journalName: string, project = false): string {
-  const dir = initPluginDir(project);
-  const id = journalName.toLowerCase().replace(/\s+/g, '-');
-  const filePath = path.join(dir, `${id}.yaml`);
-
-  if (fs.existsSync(filePath)) {
-    throw new Error(`Profile already exists: ${filePath}`);
-  }
-
-  const content = createProfileTemplate(journalName);
-  fs.writeFileSync(filePath, content, 'utf-8');
-
-  return filePath;
-}
-
-/**
- * List all custom profiles
- */
-export function listCustomProfiles(): ProfileListEntry[] {
-  const result: ProfileListEntry[] = [];
-
-  // User profiles
-  if (fs.existsSync(USER_PLUGINS_DIR)) {
-    const files = fs.readdirSync(USER_PLUGINS_DIR).filter(f =>
-      f.endsWith('.yaml') || f.endsWith('.yml') || f.endsWith('.json')
-    );
-
-    for (const file of files) {
-      try {
-        const filePath = path.join(USER_PLUGINS_DIR, file);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const profile = file.endsWith('.json') ? JSON.parse(content) : yaml.parse(content);
-
-        if (validateProfile(profile)) {
-          result.push({
-            id: profile.id || path.basename(file, path.extname(file)),
-            name: profile.name,
-            source: 'user',
-            path: filePath,
-          });
-        }
-      } catch {
-        // Skip invalid profiles
-      }
-    }
-  }
-
-  // Project profiles
-  if (fs.existsSync(PROJECT_PLUGINS_DIR)) {
-    const files = fs.readdirSync(PROJECT_PLUGINS_DIR).filter(f =>
-      f.endsWith('.yaml') || f.endsWith('.yml') || f.endsWith('.json')
-    );
-
-    for (const file of files) {
-      try {
-        const filePath = path.join(PROJECT_PLUGINS_DIR, file);
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const profile = file.endsWith('.json') ? JSON.parse(content) : yaml.parse(content);
-
-        if (validateProfile(profile)) {
-          result.push({
-            id: profile.id || path.basename(file, path.extname(file)),
-            name: profile.name,
-            source: 'project',
-            path: filePath,
-          });
-        }
-      } catch {
-        // Skip invalid profiles
-      }
-    }
-  }
-
-  return result;
-}

package/lib/postprocess.ts

@@ -1,188 +0,0 @@
-/**
- * Postprocess scripting for docrev
- *
- * Allows users to run custom scripts after output generation.
- * Supports shell scripts, PowerShell, Python, and Node.js.
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { spawn } from 'child_process';
-
-/**
- * Script execution result
- */
-interface ExecutionResult {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  error?: string;
-}
-
-/**
- * Execution options
- */
-interface ExecutionOptions {
-  verbose?: boolean;
-}
-
-/**
- * Postprocess result
- */
-interface PostprocessResult {
-  success: boolean;
-  error?: string;
-}
-
-/**
- * Execute a script with environment variables
- */
-export async function executeScript(
-  scriptPath: string,
-  env: Record<string, string>,
-  options: ExecutionOptions = {}
-): Promise<ExecutionResult> {
-  return new Promise((resolve) => {
-    const ext = path.extname(scriptPath).toLowerCase();
-    const isWindows = process.platform === 'win32';
-    let command: string;
-    let args: string[];
-    let useShell: boolean;
-
-    // Determine how to run based on extension
-    if (ext === '.ps1') {
-      command = 'powershell';
-      args = ['-ExecutionPolicy', 'Bypass', '-File', scriptPath];
-      useShell = false;
-    } else if (ext === '.py') {
-      // Python needs shell on Windows for PATH resolution
-      command = isWindows ? 'python' : 'python3';
-      // On Windows, wrap path in quotes to handle spaces
-      args = [isWindows ? `"${scriptPath}"` : scriptPath];
-      useShell = isWindows;
-    } else if (ext === '.js' || ext === '.mjs') {
-      // Node.js is typically in PATH and works without shell
-      command = process.execPath; // Use the same Node that's running this script
-      args = [scriptPath];
-      useShell = false;
-    } else {
-      // Assume shell script (.sh or no extension)
-      command = isWindows ? 'bash' : '/bin/bash';
-      args = [scriptPath];
-      useShell = false;
-    }
-
-    const proc = spawn(command, args, {
-      env: { ...process.env, ...env },
-      cwd: path.dirname(scriptPath),
-      stdio: ['ignore', 'pipe', 'pipe'],
-      shell: useShell,
-      // On Windows with shell, use windowsVerbatimArguments to preserve paths with spaces
-      windowsVerbatimArguments: isWindows && useShell,
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    proc.stdout.on('data', (data) => {
-      stdout += data.toString();
-      if (options.verbose) {
-        process.stdout.write(data);
-      }
-    });
-
-    proc.stderr.on('data', (data) => {
-      stderr += data.toString();
-      if (options.verbose) {
-        process.stderr.write(data);
-      }
-    });
-
-    proc.on('error', (err) => {
-      resolve({ success: false, stdout, stderr, error: err.message });
-    });
-
-    proc.on('close', (code) => {
-      if (code === 0) {
-        resolve({ success: true, stdout, stderr });
-      } else {
-        resolve({
-          success: false,
-          stdout,
-          stderr,
-          error: `Exit code ${code}: ${stderr.trim() || 'Unknown error'}`,
-        });
-      }
-    });
-  });
-}
-
-/**
- * Run postprocess scripts for a given format
- */
-export async function runPostprocess(
-  outputPath: string,
-  format: string,
-  config: { postprocess?: Record<string, string>; _configPath?: string; [key: string]: unknown },
-  options: ExecutionOptions = {}
-): Promise<PostprocessResult> {
-  const postprocessConfig = config.postprocess || {};
-
-  // Collect scripts to run (format-specific + all)
-  const scripts: string[] = [];
-  if (postprocessConfig[format]) {
-    scripts.push(postprocessConfig[format]);
-  }
-  if (postprocessConfig.all) {
-    scripts.push(postprocessConfig.all);
-  }
-
-  if (scripts.length === 0) {
-    return { success: true };
-  }
-
-  const directory = path.dirname(outputPath);
-  const errors: string[] = [];
-
-  for (const scriptPath of scripts) {
-    const absoluteScript = path.isAbsolute(scriptPath)
-      ? scriptPath
-      : path.join(directory, scriptPath);
-
-    if (!fs.existsSync(absoluteScript)) {
-      errors.push(`Postprocess script not found: ${scriptPath}`);
-      continue;
-    }
-
-    try {
-      if (options.verbose) {
-        console.log(`Running postprocess script: ${scriptPath}`);
-      }
-
-      const result = await executeScript(
-        absoluteScript,
-        {
-          OUTPUT_FILE: outputPath,
-          OUTPUT_FORMAT: format,
-          PROJECT_DIR: directory,
-          CONFIG_PATH: config._configPath || '',
-        },
-        options
-      );
-
-      if (!result.success) {
-        errors.push(`Script ${scriptPath} failed: ${result.error}`);
-      } else if (options.verbose) {
-        console.log(`Postprocess script completed: ${scriptPath}`);
-      }
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      errors.push(`Script ${scriptPath} error: ${message}`);
-    }
-  }
-
-  return {
-    success: errors.length === 0,
-    error: errors.length > 0 ? errors.join('\n') : undefined,
-  };
-}

package/lib/pptx-color-filter.lua

@@ -1,37 +0,0 @@
--- Pandoc Lua filter to add color support for PPTX
--- Handles [text]{color=#RRGGBB} syntax
-
-function Span(elem)
-  local color = elem.attributes['color']
-  if color then
-    -- Remove # if present
-    color = color:gsub('^#', '')
-
-    -- Create raw OpenXML for colored text
-    local content_text = pandoc.utils.stringify(elem.content)
-
-    -- Check if content has bold
-    local is_bold = false
-    for _, item in ipairs(elem.content) do
-      if item.t == 'Strong' then
-        is_bold = true
-        content_text = pandoc.utils.stringify(item.content)
-        break
-      end
-    end
-
-    local bold_attr = ''
-    if is_bold then
-      bold_attr = ' b="1"'
-    end
-
-    -- Return raw OOXML span with color
-    local ooxml = string.format(
-      '<a:r><a:rPr%s><a:solidFill><a:srgbClr val="%s"/></a:solidFill></a:rPr><a:t>%s</a:t></a:r>',
-      bold_attr, color, content_text
-    )
-
-    return pandoc.RawInline('openxml', ooxml)
-  end
-  return elem
-end