legal-markdown-js 0.1.0

package/dist/core/parsers/yaml-parser.js

@@ -0,0 +1,321 @@
+"use strict";
+/**
+ * @fileoverview YAML Front Matter Parser for Legal Markdown Documents
+ *
+ * This module provides functionality to parse YAML front matter from Legal Markdown
+ * documents, extracting metadata and configuration options for document processing.
+ * It handles both valid and invalid YAML gracefully, with options for strict error
+ * handling when needed.
+ *
+ * Features:
+ * - YAML front matter parsing with js-yaml library
+ * - Graceful error handling for malformed YAML
+ * - Metadata extraction and validation
+ * - Content separation from front matter
+ * - YAML serialization utilities
+ * - Metadata output configuration extraction
+ *
+ * @example
+ * ```typescript
+ * import { parseYamlFrontMatter } from './yaml-parser';
+ *
+ * const content = `---
+ * title: Legal Agreement
+ * date: 2024-01-01
+ * parties:
+ *   - name: Company A
+ *     role: Provider
+ * ---
+ * # Agreement Content
+ * This is the document content.`;
+ *
+ * const result = parseYamlFrontMatter(content);
+ * console.log(result.metadata.title); // "Legal Agreement"
+ * console.log(result.content); // "# Agreement Content\nThis is the document content."
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYamlFrontMatter = parseYamlFrontMatter;
+exports.serializeToYaml = serializeToYaml;
+exports.extractMetadataOutputConfig = extractMetadataOutputConfig;
+const yaml = __importStar(require("js-yaml"));
+/**
+ * Parses YAML Front Matter from a markdown document
+ *
+ * Extracts and parses YAML metadata from the beginning of a document,
+ * separated by triple dashes (---). The parser handles malformed YAML
+ * gracefully unless strict error handling is enabled.
+ *
+ * @param {string} content - The content of the document to parse
+ * @param {boolean} [throwOnError=false] - Whether to throw errors on invalid YAML
+ * @returns {YamlParsingResult} Object containing the content without YAML and the parsed metadata
+ * @throws {Error} When throwOnError is true and YAML parsing fails
+ * @example
+ * ```typescript
+ * // Basic usage with valid YAML
+ * const content = `---
+ * title: Contract
+ * version: 1.0
+ * ---
+ * # Contract Content`;
+ *
+ * const result = parseYamlFrontMatter(content);
+ * // result.metadata = { title: "Contract", version: 1.0 }
+ * // result.content = "# Contract Content"
+ *
+ * // Usage with error handling
+ * const malformedContent = `---
+ * title: Contract
+ * invalid: yaml: content
+ * ---
+ * # Content`;
+ *
+ * const safeResult = parseYamlFrontMatter(malformedContent, false);
+ * // Returns original content with empty metadata
+ *
+ * const strictResult = parseYamlFrontMatter(malformedContent, true);
+ * // Throws Error: "Invalid YAML Front Matter: ..."
+ * ```
+ */
+function parseYamlFrontMatter(content, throwOnError = false) {
+    // Default result
+    const defaultResult = {
+        content,
+        metadata: {},
+    };
+    // Check if content starts with YAML delimiter
+    if (!content.startsWith('---')) {
+        return defaultResult;
+    }
+    // Find the closing delimiter
+    const endDelimiterIndex = content.indexOf('---', 3);
+    if (endDelimiterIndex === -1) {
+        return defaultResult;
+    }
+    // Extract YAML content
+    let yamlContent = content.substring(3, endDelimiterIndex).trim();
+    const remainingContent = content.substring(endDelimiterIndex + 3).trim();
+    // Process @today references in YAML content before parsing
+    yamlContent = processDateReferencesInYaml(yamlContent);
+    try {
+        // Parse YAML
+        const metadata = yaml.load(yamlContent);
+        // Handle empty YAML
+        if (!metadata || typeof metadata !== 'object') {
+            return {
+                content: remainingContent,
+                metadata: {},
+            };
+        }
+        return {
+            content: remainingContent,
+            metadata,
+        };
+    }
+    catch (error) {
+        if (throwOnError) {
+            // Throw error for CLI to handle
+            throw new Error(`Invalid YAML Front Matter: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        else {
+            // Return original content if YAML parsing fails (graceful handling)
+            // Silently ignore YAML parsing errors unless throwOnError is true
+            return defaultResult;
+        }
+    }
+}
+/**
+ * Serializes metadata to YAML format
+ *
+ * Converts a JavaScript object to YAML string format using js-yaml library.
+ * Handles serialization errors gracefully by returning an empty string and
+ * logging the error to the console.
+ *
+ * @param {Record<string, any>} metadata - The metadata object to serialize
+ * @returns {string} YAML string representation of the metadata
+ * @example
+ * ```typescript
+ * const metadata = {
+ *   title: "Legal Agreement",
+ *   date: "2024-01-01",
+ *   parties: [
+ *     { name: "Company A", role: "Provider" },
+ *     { name: "Company B", role: "Client" }
+ *   ]
+ * };
+ *
+ * const yamlString = serializeToYaml(metadata);
+ * console.log(yamlString);
+ * // Output:
+ * // title: Legal Agreement
+ * // date: '2024-01-01'
+ * // parties:
+ * //   - name: Company A
+ * //     role: Provider
+ * //   - name: Company B
+ * //     role: Client
+ * ```
+ */
+function serializeToYaml(metadata) {
+    try {
+        return yaml.dump(metadata);
+    }
+    catch (error) {
+        console.error('Error serializing metadata to YAML:', error);
+        return '';
+    }
+}
+/**
+ * Extracts specific metadata output configuration
+ *
+ * Parses document metadata to extract configuration options for metadata output,
+ * including file paths, formats, and inclusion settings. This function looks for
+ * specially named metadata fields that control how processed metadata is exported.
+ *
+ * @param {Record<string, any>} metadata - The document metadata to extract configuration from
+ * @returns {Object} Configuration object for metadata output
+ * @returns {string} [returns.yamlOutput] - Path for YAML metadata output file
+ * @returns {string} [returns.jsonOutput] - Path for JSON metadata output file
+ * @returns {string} [returns.outputPath] - General output path for metadata files
+ * @returns {boolean} [returns.includeOriginal] - Whether to include original metadata in output
+ * @example
+ * ```typescript
+ * const metadata = {
+ *   title: "Contract",
+ *   "meta-yaml-output": "contract-metadata.yml",
+ *   "meta-json-output": "contract-metadata.json",
+ *   "meta-output-path": "./output/",
+ *   "meta-include-original": true
+ * };
+ *
+ * const config = extractMetadataOutputConfig(metadata);
+ * console.log(config);
+ * // Output:
+ * // {
+ * //   yamlOutput: "contract-metadata.yml",
+ * //   jsonOutput: "contract-metadata.json",
+ * //   outputPath: "./output/",
+ * //   includeOriginal: true
+ * // }
+ * ```
+ */
+function extractMetadataOutputConfig(metadata) {
+    return {
+        yamlOutput: metadata['meta-yaml-output'],
+        jsonOutput: metadata['meta-json-output'],
+        outputPath: metadata['meta-output-path'],
+        includeOriginal: metadata['meta-include-original'],
+    };
+}
+/**
+ * Processes @today references in YAML content before parsing
+ *
+ * Replaces @today references with properly formatted date strings that are valid YAML.
+ * This prevents YAML parsing errors when @today is used in frontmatter.
+ *
+ * @private
+ * @param {string} yamlContent - The raw YAML content containing @today references
+ * @returns {string} YAML content with @today references replaced by actual dates
+ * @example
+ * ```typescript
+ * const yamlContent = `
+ * title: Document
+ * date: @today
+ * deadline: @today[long]
+ * `;
+ *
+ * const processed = processDateReferencesInYaml(yamlContent);
+ * // Returns:
+ * // title: Document
+ * // date: "2024-01-15"
+ * // deadline: "January 15, 2024"
+ * ```
+ */
+function processDateReferencesInYaml(yamlContent) {
+    // Regular expression to match @today references with optional format specifiers
+    const todayPattern = /@today(?:\[([^\]]+)\])?/g;
+    return yamlContent.replace(todayPattern, (match, formatOverride) => {
+        // Use format override if provided, otherwise use ISO format for YAML compatibility
+        const format = formatOverride || 'YYYY-MM-DD';
+        const formattedDate = formatDateForYaml(new Date(), format);
+        // Quote the date string to ensure it's valid YAML
+        return `"${formattedDate}"`;
+    });
+}
+/**
+ * Formats a date for YAML compatibility
+ *
+ * @private
+ * @param {Date} date - The date to format
+ * @param {string} format - Format specification
+ * @returns {string} Formatted date string
+ */
+function formatDateForYaml(date, format) {
+    try {
+        // Handle different format patterns
+        switch (format.toLowerCase()) {
+            case 'iso':
+            case 'yyyy-mm-dd':
+                return date.toISOString().split('T')[0];
+            case 'long':
+                return date.toLocaleDateString('en-US', {
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                });
+            case 'medium':
+                return date.toLocaleDateString('en-US', {
+                    year: 'numeric',
+                    month: 'short',
+                    day: 'numeric',
+                });
+            case 'short':
+                return date.toLocaleDateString('en-US', {
+                    year: '2-digit',
+                    month: 'short',
+                    day: 'numeric',
+                });
+            default:
+                // For any other format, default to ISO
+                return date.toISOString().split('T')[0];
+        }
+    }
+    catch (error) {
+        // Fallback to ISO format if there's an error
+        return date.toISOString().split('T')[0];
+    }
+}
+//# sourceMappingURL=yaml-parser.js.map

package/dist/core/parsers/yaml-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-parser.js","sourceRoot":"","sources":["../../../src/core/parsers/yaml-parser.ts"],"names":[],"mappings":"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"}

package/dist/core/processors/clause-processor.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Optional Clause Processing Module for Legal Markdown Documents
+ *
+ * This module provides functionality to process conditional clauses in Legal Markdown
+ * documents, allowing for dynamic content inclusion based on metadata conditions.
+ * It supports complex boolean logic with AND/OR operations, equality comparisons,
+ * and nested value access for sophisticated document customization.
+ *
+ * Features:
+ * - Conditional clause syntax: [content]{condition}
+ * - Boolean logic with AND/OR operations
+ * - Equality and inequality comparisons
+ * - Nested metadata value access with dot notation
+ * - Type-aware value comparison (strings, numbers, booleans)
+ * - Graceful error handling for invalid conditions
+ * - Support for quoted string values in conditions
+ *
+ * @example
+ * ```typescript
+ * import { processOptionalClauses } from './clause-processor';
+ *
+ * const content = `
+ * This agreement [includes confidentiality clauses]{confidentiality}
+ * [and has a termination period of {{termination_days}} days]{termination_days}
+ * [with special provisions for European clients]{client.region = "EU"}.
+ * `;
+ *
+ * const metadata = {
+ *   confidentiality: true,
+ *   termination_days: 30,
+ *   client: { region: "EU" }
+ * };
+ *
+ * const processed = processOptionalClauses(content, metadata);
+ * console.log(processed);
+ * // Output:
+ * // This agreement includes confidentiality clauses
+ * // and has a termination period of 30 days
+ * // with special provisions for European clients.
+ * ```
+ */
+/**
+ * Processes optional clauses in a LegalMarkdown document
+ *
+ * Evaluates conditional clauses using the syntax [content]{condition} and includes
+ * or excludes content based on metadata values. Supports complex boolean logic
+ * and various comparison operators for sophisticated document customization.
+ *
+ * @param {string} content - The document content containing optional clauses
+ * @param {Record<string, any>} metadata - Document metadata with clause conditions
+ * @returns {string} Processed content with conditional clauses evaluated
+ * @example
+ * ```typescript
+ * // Simple boolean condition
+ * const content1 = '[This clause is included]{include_special}';
+ * const metadata1 = { include_special: true };
+ * const result1 = processOptionalClauses(content1, metadata1);
+ * // Output: "This clause is included"
+ *
+ * // Complex condition with AND/OR logic
+ * const content2 = '[Premium features available]{premium = true AND region != "restricted"}';
+ * const metadata2 = { premium: true, region: "US" };
+ * const result2 = processOptionalClauses(content2, metadata2);
+ * // Output: "Premium features available"
+ *
+ * // Nested metadata access
+ * const content3 = '[European compliance required]{client.location.country = "DE"}';
+ * const metadata3 = { client: { location: { country: "DE" } } };
+ * const result3 = processOptionalClauses(content3, metadata3);
+ * // Output: "European compliance required"
+ * ```
+ */
+export declare function processOptionalClauses(content: string, metadata: Record<string, any>): string;
+//# sourceMappingURL=clause-processor.d.ts.map

package/dist/core/processors/clause-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clause-processor.d.ts","sourceRoot":"","sources":["../../../src/core/processors/clause-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAY7F"}

package/dist/core/processors/clause-processor.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * @fileoverview Optional Clause Processing Module for Legal Markdown Documents
+ *
+ * This module provides functionality to process conditional clauses in Legal Markdown
+ * documents, allowing for dynamic content inclusion based on metadata conditions.
+ * It supports complex boolean logic with AND/OR operations, equality comparisons,
+ * and nested value access for sophisticated document customization.
+ *
+ * Features:
+ * - Conditional clause syntax: [content]{condition}
+ * - Boolean logic with AND/OR operations
+ * - Equality and inequality comparisons
+ * - Nested metadata value access with dot notation
+ * - Type-aware value comparison (strings, numbers, booleans)
+ * - Graceful error handling for invalid conditions
+ * - Support for quoted string values in conditions
+ *
+ * @example
+ * ```typescript
+ * import { processOptionalClauses } from './clause-processor';
+ *
+ * const content = `
+ * This agreement [includes confidentiality clauses]{confidentiality}
+ * [and has a termination period of {{termination_days}} days]{termination_days}
+ * [with special provisions for European clients]{client.region = "EU"}.
+ * `;
+ *
+ * const metadata = {
+ *   confidentiality: true,
+ *   termination_days: 30,
+ *   client: { region: "EU" }
+ * };
+ *
+ * const processed = processOptionalClauses(content, metadata);
+ * console.log(processed);
+ * // Output:
+ * // This agreement includes confidentiality clauses
+ * // and has a termination period of 30 days
+ * // with special provisions for European clients.
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processOptionalClauses = processOptionalClauses;
+/**
+ * Processes optional clauses in a LegalMarkdown document
+ *
+ * Evaluates conditional clauses using the syntax [content]{condition} and includes
+ * or excludes content based on metadata values. Supports complex boolean logic
+ * and various comparison operators for sophisticated document customization.
+ *
+ * @param {string} content - The document content containing optional clauses
+ * @param {Record<string, any>} metadata - Document metadata with clause conditions
+ * @returns {string} Processed content with conditional clauses evaluated
+ * @example
+ * ```typescript
+ * // Simple boolean condition
+ * const content1 = '[This clause is included]{include_special}';
+ * const metadata1 = { include_special: true };
+ * const result1 = processOptionalClauses(content1, metadata1);
+ * // Output: "This clause is included"
+ *
+ * // Complex condition with AND/OR logic
+ * const content2 = '[Premium features available]{premium = true AND region != "restricted"}';
+ * const metadata2 = { premium: true, region: "US" };
+ * const result2 = processOptionalClauses(content2, metadata2);
+ * // Output: "Premium features available"
+ *
+ * // Nested metadata access
+ * const content3 = '[European compliance required]{client.location.country = "DE"}';
+ * const metadata3 = { client: { location: { country: "DE" } } };
+ * const result3 = processOptionalClauses(content3, metadata3);
+ * // Output: "European compliance required"
+ * ```
+ */
+function processOptionalClauses(content, metadata) {
+    // Regular expression to match optional clauses
+    // Format: [Optional text]{condition}
+    const optionalClausePattern = /\[(.*?)\]\{(.*?)\}/gs;
+    return content.replace(optionalClausePattern, (match, text, condition) => {
+        // Evaluate the condition
+        const shouldInclude = evaluateCondition(condition, metadata);
+        // Include the text if condition is true, otherwise return empty string
+        return shouldInclude ? text : '';
+    });
+}
+/**
+ * Evaluates a condition expression against metadata
+ *
+ * Parses and evaluates condition expressions that can include simple variable
+ * references, equality/inequality comparisons, and boolean logic with AND/OR
+ * operations. Supports nested metadata access using dot notation.
+ *
+ * @private
+ * @param {string} condition - Condition expression to evaluate
+ * @param {Record<string, any>} metadata - Document metadata to test against
+ * @returns {boolean} True if condition evaluates to true, false otherwise
+ * @example
+ * ```typescript
+ * const metadata = {
+ *   active: true,
+ *   user: { role: "admin", level: 5 },
+ *   region: "US"
+ * };
+ *
+ * console.log(evaluateCondition("active", metadata));                    // true
+ * console.log(evaluateCondition("user.role = \"admin\"", metadata));      // true
+ * console.log(evaluateCondition("user.level != 3", metadata));          // true
+ * console.log(evaluateCondition("active AND region = \"US\"", metadata)); // true
+ * console.log(evaluateCondition("active OR region = \"EU\"", metadata));  // true
+ * ```
+ */
+function evaluateCondition(condition, metadata) {
+    // Handle empty condition (always true)
+    if (!condition.trim()) {
+        return true;
+    }
+    // Simple variable reference (e.g., "include_clause")
+    if (!condition.includes('=') &&
+        !condition.includes('!') &&
+        !condition.includes('AND') &&
+        !condition.includes('OR')) {
+        const value = getNestedValue(metadata, condition.trim());
+        return Boolean(value);
+    }
+    // Complex conditions
+    try {
+        // Handle logical AND first (higher precedence in processing)
+        if (condition.includes(' AND ')) {
+            const subConditions = condition.split(' AND ').map(c => c.trim());
+            return subConditions.every(cond => evaluateCondition(cond, metadata));
+        }
+        // Handle logical OR
+        if (condition.includes(' OR ')) {
+            const subConditions = condition.split(' OR ').map(c => c.trim());
+            return subConditions.some(cond => evaluateCondition(cond, metadata));
+        }
+        // Handle equality/inequality (after logical operators)
+        if (condition.includes('=')) {
+            // Parse "key = value" or "key != value"
+            const isNotEqual = condition.includes('!=');
+            const parts = condition.split(isNotEqual ? '!=' : '=').map(p => p.trim());
+            if (parts.length !== 2) {
+                return false;
+            }
+            const [key, valueStr] = parts;
+            const metadataValue = getNestedValue(metadata, key);
+            // Parse the value string (handle quoted strings, booleans, numbers)
+            let expectedValue = valueStr;
+            if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+                expectedValue = valueStr.slice(1, -1);
+            }
+            else if (valueStr === 'true') {
+                expectedValue = true;
+            }
+            else if (valueStr === 'false') {
+                expectedValue = false;
+            }
+            else if (!isNaN(Number(valueStr))) {
+                expectedValue = Number(valueStr);
+            }
+            return isNotEqual ? metadataValue !== expectedValue : metadataValue === expectedValue;
+        }
+        // Default to false for unknown condition formats
+        return false;
+    }
+    catch (error) {
+        console.error('Error evaluating condition:', error);
+        return false;
+    }
+}
+/**
+ * Gets a potentially nested value from an object
+ *
+ * Traverses an object using dot notation to access nested properties safely.
+ * Returns undefined if any part of the path doesn't exist, preventing errors
+ * when accessing deeply nested properties.
+ *
+ * @private
+ * @param {Record<string, any>} obj - Object to extract value from
+ * @param {string} path - Dot-separated path to the value (e.g., "user.profile.name")
+ * @returns {any} The value at the specified path, or undefined if not found
+ * @example
+ * ```typescript
+ * const obj = {
+ *   user: {
+ *     profile: {
+ *       name: "John",
+ *       settings: { theme: "dark" }
+ *     },
+ *     active: true
+ *   }
+ * };
+ *
+ * console.log(getNestedValue(obj, "user.profile.name"));           // "John"
+ * console.log(getNestedValue(obj, "user.active"));                 // true
+ * console.log(getNestedValue(obj, "user.profile.settings.theme")); // "dark"
+ * console.log(getNestedValue(obj, "user.nonexistent"));            // undefined
+ * console.log(getNestedValue(obj, "missing.path"));                // undefined
+ * ```
+ */
+function getNestedValue(obj, path) {
+    const keys = path.split('.');
+    let value = obj;
+    for (const key of keys) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        value = value[key];
+    }
+    return value;
+}
+//# sourceMappingURL=clause-processor.js.map

package/dist/core/processors/clause-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clause-processor.js","sourceRoot":"","sources":["../../../src/core/processors/clause-processor.ts"],"names":[],"mappings":"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"}