docrev 0.9.11 → 0.9.14

package/lib/schema.ts

@@ -1,417 +1,417 @@
-/**
- * JSON Schema validation for rev.yaml configuration
- */
-
-/**
- * Validation error
- */
-interface ValidationError {
-  path: string;
-  message: string;
-  value?: unknown;
-}
-
-/**
- * Validation warning
- */
-interface ValidationWarning {
-  path: string;
-  message: string;
-}
-
-/**
- * Validation result
- */
-interface ValidationResult {
-  valid: boolean;
-  errors: ValidationError[];
-  warnings: ValidationWarning[];
-}
-
-/**
- * JSON Schema type
- */
-interface Schema {
-  $schema?: string;
-  title?: string;
-  description?: string;
-  type?: string;
-  properties?: Record<string, Schema>;
-  required?: string[];
-  items?: Schema;
-  oneOf?: Schema[];
-  enum?: string[];
-  pattern?: string;
-  format?: string;
-  minimum?: number;
-  maximum?: number;
-  minItems?: number;
-  maxItems?: number;
-  additionalProperties?: boolean;
-  default?: unknown;
-}
-
-/**
- * JSON Schema for rev.yaml
- */
-export const revYamlSchema: Schema = {
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'rev.yaml configuration',
-  description: 'Configuration file for docrev document workflow',
-  type: 'object',
-  properties: {
-    title: {
-      type: 'string',
-      description: 'Document title',
-    },
-    version: {
-      type: 'string',
-      description: 'Document version',
-    },
-    authors: {
-      type: 'array',
-      description: 'List of authors',
-      items: {
-        oneOf: [
-          { type: 'string' },
-          {
-            type: 'object',
-            properties: {
-              name: { type: 'string' },
-              affiliation: { type: 'string' },
-              email: { type: 'string', format: 'email' },
-              orcid: { type: 'string', pattern: '^\\d{4}-\\d{4}-\\d{4}-\\d{3}[0-9X]$' },
-            },
-            required: ['name'],
-          },
-        ],
-      },
-    },
-    journal: {
-      type: 'string',
-      description: 'Journal profile name for formatting defaults and validation',
-    },
-    sections: {
-      type: 'array',
-      description: 'Ordered list of section files to include',
-      items: { type: 'string', pattern: '.*\\.md$' },
-    },
-    bibliography: {
-      type: 'string',
-      description: 'Path to bibliography file (.bib)',
-      pattern: '.*\\.bib$',
-    },
-    csl: {
-      type: 'string',
-      description: 'Path to CSL citation style file',
-    },
-    crossref: {
-      type: 'object',
-      description: 'pandoc-crossref settings',
-      properties: {
-        figureTitle: { type: 'string', default: 'Figure' },
-        tableTitle: { type: 'string', default: 'Table' },
-        figPrefix: {
-          oneOf: [
-            { type: 'string' },
-            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
-          ],
-        },
-        tblPrefix: {
-          oneOf: [
-            { type: 'string' },
-            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
-          ],
-        },
-        eqnPrefix: {
-          oneOf: [
-            { type: 'string' },
-            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
-          ],
-        },
-        secPrefix: {
-          oneOf: [
-            { type: 'string' },
-            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
-          ],
-        },
-        linkReferences: { type: 'boolean', default: true },
-      },
-      additionalProperties: true,
-    },
-    pdf: {
-      type: 'object',
-      description: 'PDF output settings',
-      properties: {
-        template: { type: 'string' },
-        documentclass: {
-          type: 'string',
-          enum: ['article', 'report', 'book', 'memoir', 'scrartcl', 'scrreprt', 'scrbook'],
-          default: 'article',
-        },
-        fontsize: {
-          type: 'string',
-          pattern: '^\\d{1,2}pt$',
-          default: '12pt',
-        },
-        geometry: { type: 'string', default: 'margin=1in' },
-        linestretch: { type: 'number', minimum: 1, maximum: 3, default: 1.5 },
-        numbersections: { type: 'boolean', default: false },
-        toc: { type: 'boolean', default: false },
-        header: { type: 'string' },
-        footer: { type: 'string' },
-      },
-      additionalProperties: true,
-    },
-    docx: {
-      type: 'object',
-      description: 'Word output settings',
-      properties: {
-        reference: { type: 'string', description: 'Reference document for styling' },
-        keepComments: { type: 'boolean', default: true },
-        toc: { type: 'boolean', default: false },
-      },
-      additionalProperties: true,
-    },
-    tex: {
-      type: 'object',
-      description: 'LaTeX output settings',
-      properties: {
-        standalone: { type: 'boolean', default: true },
-      },
-      additionalProperties: true,
-    },
-  },
-  additionalProperties: true,
-};
-
-/**
- * Validate a value against a simple schema
- */
-function validateValue(value: unknown, schema: Schema, path = ''): ValidationError[] {
-  const errors: ValidationError[] = [];
-
-  // Handle oneOf
-  if (schema.oneOf) {
-    const validForAny = schema.oneOf.some((subSchema) => {
-      const subErrors = validateValue(value, subSchema, path);
-      return subErrors.length === 0;
-    });
-    if (!validForAny) {
-      errors.push({
-        path,
-        message: `Value does not match any allowed type`,
-        value,
-      });
-    }
-    return errors;
-  }
-
-  // Type check
-  if (schema.type) {
-    const actualType = Array.isArray(value) ? 'array' : typeof value;
-    if (actualType !== schema.type) {
-      errors.push({
-        path,
-        message: `Expected ${schema.type}, got ${actualType}`,
-        value,
-      });
-      return errors; // Stop further validation if type is wrong
-    }
-  }
-
-  // String validation
-  if (schema.type === 'string' && typeof value === 'string') {
-    if (schema.pattern) {
-      const regex = new RegExp(schema.pattern);
-      if (!regex.test(value)) {
-        errors.push({
-          path,
-          message: `Value "${value}" does not match pattern ${schema.pattern}`,
-          value,
-        });
-      }
-    }
-    if (schema.enum && !schema.enum.includes(value)) {
-      errors.push({
-        path,
-        message: `Value "${value}" must be one of: ${schema.enum.join(', ')}`,
-        value,
-      });
-    }
-  }
-
-  // Number validation
-  if (schema.type === 'number' && typeof value === 'number') {
-    if (schema.minimum !== undefined && value < schema.minimum) {
-      errors.push({
-        path,
-        message: `Value ${value} is less than minimum ${schema.minimum}`,
-        value,
-      });
-    }
-    if (schema.maximum !== undefined && value > schema.maximum) {
-      errors.push({
-        path,
-        message: `Value ${value} is greater than maximum ${schema.maximum}`,
-        value,
-      });
-    }
-  }
-
-  // Array validation
-  if (schema.type === 'array' && Array.isArray(value)) {
-    if (schema.minItems !== undefined && value.length < schema.minItems) {
-      errors.push({
-        path,
-        message: `Array must have at least ${schema.minItems} items`,
-        value,
-      });
-    }
-    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
-      errors.push({
-        path,
-        message: `Array must have at most ${schema.maxItems} items`,
-        value,
-      });
-    }
-    if (schema.items) {
-      value.forEach((item, index) => {
-        errors.push(...validateValue(item, schema.items!, `${path}[${index}]`));
-      });
-    }
-  }
-
-  // Object validation
-  if (schema.type === 'object' && typeof value === 'object' && value !== null) {
-    const obj = value as Record<string, unknown>;
-    if (schema.properties) {
-      for (const [key, propSchema] of Object.entries(schema.properties)) {
-        if (obj[key] !== undefined) {
-          errors.push(...validateValue(obj[key], propSchema, path ? `${path}.${key}` : key));
-        }
-      }
-    }
-    if (schema.required) {
-      for (const key of schema.required) {
-        if (obj[key] === undefined) {
-          errors.push({
-            path: path ? `${path}.${key}` : key,
-            message: `Required property "${key}" is missing`,
-            value: undefined,
-          });
-        }
-      }
-    }
-  }
-
-  return errors;
-}
-
-/**
- * Validate rev.yaml configuration
- */
-export function validateConfig(config: Record<string, unknown>): ValidationResult {
-  const errors = validateValue(config, revYamlSchema);
-  const warnings: ValidationWarning[] = [];
-
-  // Additional semantic validations
-  if (config.sections && Array.isArray(config.sections) && config.sections.length === 0) {
-    warnings.push({
-      path: 'sections',
-      message: 'No sections specified - build will auto-detect .md files',
-    });
-  }
-
-  if (config.bibliography && typeof config.bibliography === 'string' && !config.bibliography.endsWith('.bib')) {
-    warnings.push({
-      path: 'bibliography',
-      message: 'Bibliography file should have .bib extension',
-    });
-  }
-
-  const pdf = config.pdf as { linestretch?: number } | undefined;
-  if (pdf?.linestretch && (pdf.linestretch < 1 || pdf.linestretch > 3)) {
-    warnings.push({
-      path: 'pdf.linestretch',
-      message: 'Line stretch values outside 1-3 range may produce unexpected results',
-    });
-  }
-
-  // Check for common typos
-  const knownKeys = Object.keys(revYamlSchema.properties || {});
-  for (const key of Object.keys(config)) {
-    if (key.startsWith('_')) continue; // Internal keys
-    if (!knownKeys.includes(key)) {
-      // Check for similar keys (possible typos)
-      const similar = knownKeys.find(
-        (k) => levenshtein(key.toLowerCase(), k.toLowerCase()) <= 2
-      );
-      if (similar) {
-        warnings.push({
-          path: key,
-          message: `Unknown property "${key}" - did you mean "${similar}"?`,
-        });
-      }
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-    warnings,
-  };
-}
-
-/**
- * Format validation results for display
- */
-export function formatValidationResult(
-  result: ValidationResult,
-  chalk: { red: (s: string) => string; yellow: (s: string) => string; green: (s: string) => string }
-): string {
-  const lines: string[] = [];
-
-  if (result.errors.length > 0) {
-    lines.push(chalk.red('Configuration errors:'));
-    for (const error of result.errors) {
-      lines.push(chalk.red(`  ✗ ${error.path}: ${error.message}`));
-    }
-  }
-
-  if (result.warnings.length > 0) {
-    if (lines.length > 0) lines.push('');
-    lines.push(chalk.yellow('Warnings:'));
-    for (const warning of result.warnings) {
-      lines.push(chalk.yellow(`  ! ${warning.path}: ${warning.message}`));
-    }
-  }
-
-  if (result.valid && result.warnings.length === 0) {
-    lines.push(chalk.green('✓ Configuration is valid'));
-  }
-
-  return lines.join('\n');
-}
-
-/**
- * Levenshtein distance for typo detection
- */
-function levenshtein(a: string, b: string): number {
-  const matrix = Array(b.length + 1)
-    .fill(null)
-    .map(() => Array(a.length + 1).fill(null));
-  for (let i = 0; i <= a.length; i++) matrix[0][i] = i;
-  for (let j = 0; j <= b.length; j++) matrix[j][0] = j;
-  for (let j = 1; j <= b.length; j++) {
-    for (let i = 1; i <= a.length; i++) {
-      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[j][i] = Math.min(
-        matrix[j][i - 1] + 1,
-        matrix[j - 1][i] + 1,
-        matrix[j - 1][i - 1] + cost
-      );
-    }
-  }
-  return matrix[b.length][a.length];
-}
+/**
+ * JSON Schema validation for rev.yaml configuration
+ */
+
+/**
+ * Validation error
+ */
+interface ValidationError {
+  path: string;
+  message: string;
+  value?: unknown;
+}
+
+/**
+ * Validation warning
+ */
+interface ValidationWarning {
+  path: string;
+  message: string;
+}
+
+/**
+ * Validation result
+ */
+interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+  warnings: ValidationWarning[];
+}
+
+/**
+ * JSON Schema type
+ */
+interface Schema {
+  $schema?: string;
+  title?: string;
+  description?: string;
+  type?: string;
+  properties?: Record<string, Schema>;
+  required?: string[];
+  items?: Schema;
+  oneOf?: Schema[];
+  enum?: string[];
+  pattern?: string;
+  format?: string;
+  minimum?: number;
+  maximum?: number;
+  minItems?: number;
+  maxItems?: number;
+  additionalProperties?: boolean;
+  default?: unknown;
+}
+
+/**
+ * JSON Schema for rev.yaml
+ */
+export const revYamlSchema: Schema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'rev.yaml configuration',
+  description: 'Configuration file for docrev document workflow',
+  type: 'object',
+  properties: {
+    title: {
+      type: 'string',
+      description: 'Document title',
+    },
+    version: {
+      type: 'string',
+      description: 'Document version',
+    },
+    authors: {
+      type: 'array',
+      description: 'List of authors',
+      items: {
+        oneOf: [
+          { type: 'string' },
+          {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              affiliation: { type: 'string' },
+              email: { type: 'string', format: 'email' },
+              orcid: { type: 'string', pattern: '^\\d{4}-\\d{4}-\\d{4}-\\d{3}[0-9X]$' },
+            },
+            required: ['name'],
+          },
+        ],
+      },
+    },
+    journal: {
+      type: 'string',
+      description: 'Journal profile name for formatting defaults and validation',
+    },
+    sections: {
+      type: 'array',
+      description: 'Ordered list of section files to include',
+      items: { type: 'string', pattern: '.*\\.md$' },
+    },
+    bibliography: {
+      type: 'string',
+      description: 'Path to bibliography file (.bib)',
+      pattern: '.*\\.bib$',
+    },
+    csl: {
+      type: 'string',
+      description: 'Path to CSL citation style file',
+    },
+    crossref: {
+      type: 'object',
+      description: 'pandoc-crossref settings',
+      properties: {
+        figureTitle: { type: 'string', default: 'Figure' },
+        tableTitle: { type: 'string', default: 'Table' },
+        figPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        tblPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        eqnPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        secPrefix: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 2 },
+          ],
+        },
+        linkReferences: { type: 'boolean', default: true },
+      },
+      additionalProperties: true,
+    },
+    pdf: {
+      type: 'object',
+      description: 'PDF output settings',
+      properties: {
+        template: { type: 'string' },
+        documentclass: {
+          type: 'string',
+          enum: ['article', 'report', 'book', 'memoir', 'scrartcl', 'scrreprt', 'scrbook'],
+          default: 'article',
+        },
+        fontsize: {
+          type: 'string',
+          pattern: '^\\d{1,2}pt$',
+          default: '12pt',
+        },
+        geometry: { type: 'string', default: 'margin=1in' },
+        linestretch: { type: 'number', minimum: 1, maximum: 3, default: 1.5 },
+        numbersections: { type: 'boolean', default: false },
+        toc: { type: 'boolean', default: false },
+        header: { type: 'string' },
+        footer: { type: 'string' },
+      },
+      additionalProperties: true,
+    },
+    docx: {
+      type: 'object',
+      description: 'Word output settings',
+      properties: {
+        reference: { type: 'string', description: 'Reference document for styling' },
+        keepComments: { type: 'boolean', default: true },
+        toc: { type: 'boolean', default: false },
+      },
+      additionalProperties: true,
+    },
+    tex: {
+      type: 'object',
+      description: 'LaTeX output settings',
+      properties: {
+        standalone: { type: 'boolean', default: true },
+      },
+      additionalProperties: true,
+    },
+  },
+  additionalProperties: true,
+};
+
+/**
+ * Validate a value against a simple schema
+ */
+function validateValue(value: unknown, schema: Schema, path = ''): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  // Handle oneOf
+  if (schema.oneOf) {
+    const validForAny = schema.oneOf.some((subSchema) => {
+      const subErrors = validateValue(value, subSchema, path);
+      return subErrors.length === 0;
+    });
+    if (!validForAny) {
+      errors.push({
+        path,
+        message: `Value does not match any allowed type`,
+        value,
+      });
+    }
+    return errors;
+  }
+
+  // Type check
+  if (schema.type) {
+    const actualType = Array.isArray(value) ? 'array' : typeof value;
+    if (actualType !== schema.type) {
+      errors.push({
+        path,
+        message: `Expected ${schema.type}, got ${actualType}`,
+        value,
+      });
+      return errors; // Stop further validation if type is wrong
+    }
+  }
+
+  // String validation
+  if (schema.type === 'string' && typeof value === 'string') {
+    if (schema.pattern) {
+      const regex = new RegExp(schema.pattern);
+      if (!regex.test(value)) {
+        errors.push({
+          path,
+          message: `Value "${value}" does not match pattern ${schema.pattern}`,
+          value,
+        });
+      }
+    }
+    if (schema.enum && !schema.enum.includes(value)) {
+      errors.push({
+        path,
+        message: `Value "${value}" must be one of: ${schema.enum.join(', ')}`,
+        value,
+      });
+    }
+  }
+
+  // Number validation
+  if (schema.type === 'number' && typeof value === 'number') {
+    if (schema.minimum !== undefined && value < schema.minimum) {
+      errors.push({
+        path,
+        message: `Value ${value} is less than minimum ${schema.minimum}`,
+        value,
+      });
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+      errors.push({
+        path,
+        message: `Value ${value} is greater than maximum ${schema.maximum}`,
+        value,
+      });
+    }
+  }
+
+  // Array validation
+  if (schema.type === 'array' && Array.isArray(value)) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+      errors.push({
+        path,
+        message: `Array must have at least ${schema.minItems} items`,
+        value,
+      });
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+      errors.push({
+        path,
+        message: `Array must have at most ${schema.maxItems} items`,
+        value,
+      });
+    }
+    if (schema.items) {
+      value.forEach((item, index) => {
+        errors.push(...validateValue(item, schema.items!, `${path}[${index}]`));
+      });
+    }
+  }
+
+  // Object validation
+  if (schema.type === 'object' && typeof value === 'object' && value !== null) {
+    const obj = value as Record<string, unknown>;
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (obj[key] !== undefined) {
+          errors.push(...validateValue(obj[key], propSchema, path ? `${path}.${key}` : key));
+        }
+      }
+    }
+    if (schema.required) {
+      for (const key of schema.required) {
+        if (obj[key] === undefined) {
+          errors.push({
+            path: path ? `${path}.${key}` : key,
+            message: `Required property "${key}" is missing`,
+            value: undefined,
+          });
+        }
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Validate rev.yaml configuration
+ */
+export function validateConfig(config: Record<string, unknown>): ValidationResult {
+  const errors = validateValue(config, revYamlSchema);
+  const warnings: ValidationWarning[] = [];
+
+  // Additional semantic validations
+  if (config.sections && Array.isArray(config.sections) && config.sections.length === 0) {
+    warnings.push({
+      path: 'sections',
+      message: 'No sections specified - build will auto-detect .md files',
+    });
+  }
+
+  if (config.bibliography && typeof config.bibliography === 'string' && !config.bibliography.endsWith('.bib')) {
+    warnings.push({
+      path: 'bibliography',
+      message: 'Bibliography file should have .bib extension',
+    });
+  }
+
+  const pdf = config.pdf as { linestretch?: number } | undefined;
+  if (pdf?.linestretch && (pdf.linestretch < 1 || pdf.linestretch > 3)) {
+    warnings.push({
+      path: 'pdf.linestretch',
+      message: 'Line stretch values outside 1-3 range may produce unexpected results',
+    });
+  }
+
+  // Check for common typos
+  const knownKeys = Object.keys(revYamlSchema.properties || {});
+  for (const key of Object.keys(config)) {
+    if (key.startsWith('_')) continue; // Internal keys
+    if (!knownKeys.includes(key)) {
+      // Check for similar keys (possible typos)
+      const similar = knownKeys.find(
+        (k) => levenshtein(key.toLowerCase(), k.toLowerCase()) <= 2
+      );
+      if (similar) {
+        warnings.push({
+          path: key,
+          message: `Unknown property "${key}" - did you mean "${similar}"?`,
+        });
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Format validation results for display
+ */
+export function formatValidationResult(
+  result: ValidationResult,
+  chalk: { red: (s: string) => string; yellow: (s: string) => string; green: (s: string) => string }
+): string {
+  const lines: string[] = [];
+
+  if (result.errors.length > 0) {
+    lines.push(chalk.red('Configuration errors:'));
+    for (const error of result.errors) {
+      lines.push(chalk.red(`  ✗ ${error.path}: ${error.message}`));
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    if (lines.length > 0) lines.push('');
+    lines.push(chalk.yellow('Warnings:'));
+    for (const warning of result.warnings) {
+      lines.push(chalk.yellow(`  ! ${warning.path}: ${warning.message}`));
+    }
+  }
+
+  if (result.valid && result.warnings.length === 0) {
+    lines.push(chalk.green('✓ Configuration is valid'));
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Levenshtein distance for typo detection
+ */
+function levenshtein(a: string, b: string): number {
+  const matrix = Array(b.length + 1)
+    .fill(null)
+    .map(() => Array(a.length + 1).fill(null));
+  for (let i = 0; i <= a.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= b.length; j++) matrix[j][0] = j;
+  for (let j = 1; j <= b.length; j++) {
+    for (let i = 1; i <= a.length; i++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[j][i] = Math.min(
+        matrix[j][i - 1] + 1,
+        matrix[j - 1][i] + 1,
+        matrix[j - 1][i - 1] + cost
+      );
+    }
+  }
+  return matrix[b.length][a.length];
+}