docrev 0.8.1 → 0.8.5

package/lib/{plugins.js → plugins.ts}

@@ -11,16 +11,71 @@ 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;
+}
+
+/**
+ * Normalized profile
+ */
+interface NormalizedProfile {
+  name: string;
+  url: string | null;
+  custom: boolean;
+  requirements: ProfileRequirements;
+}
+
+/**
+ * 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
- * @returns {Object<string, Object>}
  */
-export function loadCustomProfiles() {
-  const profiles = {};
+export function loadCustomProfiles(): Record<string, NormalizedProfile> {
+  const profiles: Record<string, NormalizedProfile> = {};
 
   // Load user profiles first (lower priority)
   const userProfiles = loadProfilesFromDir(USER_PLUGINS_DIR);
@@ -35,11 +90,9 @@ export function loadCustomProfiles() {
 
 /**
  * Load profiles from a directory
- * @param {string} dir
- * @returns {Object<string, Object>}
  */
-function loadProfilesFromDir(dir) {
-  const profiles = {};
+function loadProfilesFromDir(dir: string): Record<string, NormalizedProfile> {
+  const profiles: Record<string, NormalizedProfile> = {};
 
   if (!fs.existsSync(dir)) {
     return profiles;
@@ -62,8 +115,9 @@ function loadProfilesFromDir(dir) {
           const id = profile.id || path.basename(file, path.extname(file));
           profiles[id] = normalizeProfile(profile);
         }
-      } catch (err) {
-        console.error(`Warning: Failed to load profile ${file}: ${err.message}`);
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Warning: Failed to load profile ${file}: ${message}`);
       }
     }
   } catch {
@@ -75,21 +129,21 @@ function loadProfilesFromDir(dir) {
 
 /**
  * Validate a profile structure
- * @param {Object} profile
- * @returns {boolean}
  */
-function validateProfile(profile) {
+function validateProfile(profile: unknown): profile is Profile {
   if (!profile || typeof profile !== 'object') {
     return false;
   }
 
+  const p = profile as Profile;
+
   // Must have a name
-  if (!profile.name || typeof profile.name !== 'string') {
+  if (!p.name || typeof p.name !== 'string') {
     return false;
   }
 
   // Requirements must be an object if present
-  if (profile.requirements && typeof profile.requirements !== 'object') {
+  if (p.requirements && typeof p.requirements !== 'object') {
     return false;
   }
 
@@ -98,22 +152,20 @@ function validateProfile(profile) {
 
 /**
  * Normalize profile to standard structure
- * @param {Object} profile
- * @returns {Object}
  */
-function normalizeProfile(profile) {
+function normalizeProfile(profile: Profile): NormalizedProfile {
   return {
     name: profile.name,
     url: profile.url || null,
     custom: true,
     requirements: {
-      wordLimit: profile.requirements?.wordLimit || profile.wordLimit || {},
-      references: profile.requirements?.references || profile.references || {},
-      figures: profile.requirements?.figures || profile.figures || {},
-      sections: profile.requirements?.sections || profile.sections || {},
-      authors: profile.requirements?.authors || profile.authors || {},
-      keywords: profile.requirements?.keywords || profile.keywords || null,
-      dataAvailability: profile.requirements?.dataAvailability || profile.dataAvailability || false,
+      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,
     },
   };
@@ -121,10 +173,8 @@ function normalizeProfile(profile) {
 
 /**
  * Initialize plugin directories
- * @param {boolean} project - Create project directory instead of user
- * @returns {string} Created directory path
  */
-export function initPluginDir(project = false) {
+export function initPluginDir(project = false): string {
   const dir = project ? PROJECT_PLUGINS_DIR : USER_PLUGINS_DIR;
 
   if (!fs.existsSync(dir)) {
@@ -136,9 +186,8 @@ export function initPluginDir(project = false) {
 
 /**
  * Get plugin directories info
- * @returns {{user: string, project: string, userExists: boolean, projectExists: boolean}}
  */
-export function getPluginDirs() {
+export function getPluginDirs(): PluginDirsInfo {
   return {
     user: USER_PLUGINS_DIR,
     project: PROJECT_PLUGINS_DIR,
@@ -149,10 +198,8 @@ export function getPluginDirs() {
 
 /**
  * Create a sample profile template
- * @param {string} journalName
- * @returns {string} YAML content
  */
-export function createProfileTemplate(journalName) {
+export function createProfileTemplate(journalName: string): string {
   const id = journalName.toLowerCase().replace(/\s+/g, '-');
 
   return `# Custom journal profile for ${journalName}
@@ -203,11 +250,8 @@ graphicalAbstract: false
 
 /**
  * Save a profile template
- * @param {string} journalName
- * @param {boolean} project - Save to project directory
- * @returns {string} Saved file path
  */
-export function saveProfileTemplate(journalName, project = false) {
+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`);
@@ -224,10 +268,9 @@ export function saveProfileTemplate(journalName, project = false) {
 
 /**
  * List all custom profiles
- * @returns {Array<{id: string, name: string, source: string, path: string}>}
  */
-export function listCustomProfiles() {
-  const result = [];
+export function listCustomProfiles(): ProfileListEntry[] {
+  const result: ProfileListEntry[] = [];
 
   // User profiles
   if (fs.existsSync(USER_PLUGINS_DIR)) {

package/lib/postprocess.ts

@@ -0,0 +1,188 @@
+/**
+ * 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

@@ -0,0 +1,37 @@
+-- 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