domainforge 0.13.0

package/domainforge-core/src/error/fuzzy.rs

@@ -0,0 +1,253 @@
+//! Fuzzy string matching for "did you mean?" suggestions.
+//!
+//! Implements the Levenshtein distance algorithm (Wagner-Fischer) to provide
+//! helpful suggestions when users make typos in entity names, resource names,
+//! or other identifiers.
+/// Calculate the Levenshtein distance between two strings
+///
+/// Uses the Wagner-Fischer dynamic programming algorithm with O(mn) time complexity
+/// and O(min(m,n)) space complexity.
+///
+/// # Examples
+///
+/// ```
+/// use domainforge_core::error::fuzzy::levenshtein_distance;
+///
+/// assert_eq!(levenshtein_distance("kitten", "sitting"), 3);
+/// assert_eq!(levenshtein_distance("Saturday", "Sunday"), 3);
+/// assert_eq!(levenshtein_distance("", "abc"), 3);
+/// ```
+pub fn levenshtein_distance(a: &str, b: &str) -> usize {
+    let a_len = a.chars().count();
+    let b_len = b.chars().count();
+
+    if a_len == 0 {
+        return b_len;
+    }
+    if b_len == 0 {
+        return a_len;
+    }
+
+    // Use the shorter string for the columns to minimize space
+    let (short, long, short_len) = if a_len < b_len {
+        (a, b, a_len)
+    } else {
+        (b, a, b_len)
+    };
+
+    // We only need two rows for the dynamic programming table
+    let mut prev_row: Vec<usize> = (0..=short_len).collect();
+    let mut curr_row: Vec<usize> = vec![0; short_len + 1];
+
+    let short_chars: Vec<char> = short.chars().collect();
+
+    for (i, long_char) in long.chars().enumerate() {
+        curr_row[0] = i + 1;
+
+        for (j, &short_char) in short_chars.iter().enumerate() {
+            let cost = if long_char == short_char { 0 } else { 1 };
+
+            curr_row[j + 1] = std::cmp::min(
+                std::cmp::min(
+                    curr_row[j] + 1,     // insertion
+                    prev_row[j + 1] + 1, // deletion
+                ),
+                prev_row[j] + cost, // substitution
+            );
+        }
+
+        std::mem::swap(&mut prev_row, &mut curr_row);
+    }
+
+    prev_row[short_len]
+}
+
+/// Find similar strings within a given edit distance threshold
+///
+/// Returns all candidates that are within `threshold` edits of the target string,
+/// sorted by distance (closest first).
+///
+/// # Arguments
+///
+/// * `target` - The string to match against
+/// * `candidates` - Potential matches to consider
+/// * `threshold` - Maximum edit distance to include (default recommendation: 2)
+///
+/// # Examples
+///
+/// ```
+/// use domainforge_core::error::fuzzy::suggest_similar;
+///
+/// let candidates = vec![
+///     "Warehouse".to_string(),
+///     "Factory".to_string(),
+///     "Supplier".to_string(),
+/// ];
+///
+/// let suggestions = suggest_similar("Warehous", &candidates, 2);
+/// assert_eq!(suggestions, vec!["Warehouse"]);
+/// ```
+pub fn suggest_similar(target: &str, candidates: &[String], threshold: usize) -> Vec<String> {
+    let mut matches: Vec<(String, usize)> = candidates
+        .iter()
+        .filter_map(|candidate| {
+            let distance = levenshtein_distance(target, candidate);
+            if distance <= threshold {
+                Some((candidate.clone(), distance))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Sort by distance (closest first), then alphabetically for ties
+    matches.sort_by(|a, b| a.1.cmp(&b.1).then(a.0.cmp(&b.0)));
+
+    matches.into_iter().map(|(s, _)| s).collect()
+}
+
+/// Find the single best match for a target string
+///
+/// Returns the closest match if it's within the threshold, otherwise None.
+/// If multiple candidates have the same distance, returns the first alphabetically.
+///
+/// # Arguments
+///
+/// * `target` - The string to match against
+/// * `candidates` - Potential matches to consider
+/// * `threshold` - Maximum edit distance to accept (default recommendation: 2)
+///
+/// # Examples
+///
+/// ```
+/// use domainforge_core::error::fuzzy::find_best_match;
+///
+/// let candidates = vec![
+///     "Warehouse".to_string(),
+///     "Factory".to_string(),
+/// ];
+///
+/// assert_eq!(find_best_match("Warehous", &candidates, 2), Some("Warehouse".to_string()));
+/// assert_eq!(find_best_match("XYZ", &candidates, 2), None);
+/// ```
+pub fn find_best_match(target: &str, candidates: &[String], threshold: usize) -> Option<String> {
+    suggest_similar(target, candidates, threshold)
+        .into_iter()
+        .next()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_levenshtein_distance_identical() {
+        assert_eq!(levenshtein_distance("hello", "hello"), 0);
+        assert_eq!(levenshtein_distance("", ""), 0);
+    }
+
+    #[test]
+    fn test_levenshtein_distance_empty() {
+        assert_eq!(levenshtein_distance("", "abc"), 3);
+        assert_eq!(levenshtein_distance("abc", ""), 3);
+    }
+
+    #[test]
+    fn test_levenshtein_distance_single_char() {
+        assert_eq!(levenshtein_distance("a", "b"), 1);
+        assert_eq!(levenshtein_distance("a", "a"), 0);
+    }
+
+    #[test]
+    fn test_levenshtein_distance_classic_examples() {
+        assert_eq!(levenshtein_distance("kitten", "sitting"), 3);
+        assert_eq!(levenshtein_distance("Saturday", "Sunday"), 3);
+        assert_eq!(levenshtein_distance("rosettacode", "raisethysword"), 8);
+    }
+
+    #[test]
+    fn test_levenshtein_distance_case_sensitive() {
+        assert_eq!(levenshtein_distance("Hello", "hello"), 1);
+        assert_eq!(levenshtein_distance("HELLO", "hello"), 5);
+    }
+
+    #[test]
+    fn test_suggest_similar_exact_match() {
+        let candidates = vec!["Warehouse".to_string(), "Factory".to_string()];
+        let suggestions = suggest_similar("Warehouse", &candidates, 2);
+        assert_eq!(suggestions, vec!["Warehouse"]);
+    }
+
+    #[test]
+    fn test_suggest_similar_typo() {
+        let candidates = vec![
+            "Warehouse".to_string(),
+            "Factory".to_string(),
+            "Supplier".to_string(),
+        ];
+        let suggestions = suggest_similar("Warehous", &candidates, 2);
+        assert_eq!(suggestions, vec!["Warehouse"]);
+    }
+
+    #[test]
+    fn test_suggest_similar_multiple_matches() {
+        let candidates = vec![
+            "Warehouse".to_string(),
+            "Warehouses".to_string(),
+            "Factory".to_string(),
+        ];
+        let suggestions = suggest_similar("Warehous", &candidates, 2);
+        // Both Warehouse and Warehouses are within threshold
+        assert!(suggestions.contains(&"Warehouse".to_string()));
+        assert!(suggestions.contains(&"Warehouses".to_string()));
+    }
+
+    #[test]
+    fn test_suggest_similar_no_matches() {
+        let candidates = vec!["Warehouse".to_string(), "Factory".to_string()];
+        let suggestions = suggest_similar("XYZ", &candidates, 2);
+        assert_eq!(suggestions.len(), 0);
+    }
+
+    #[test]
+    fn test_suggest_similar_sorted_by_distance() {
+        let candidates = vec![
+            "Warehouse".to_string(),
+            "Warehouses".to_string(),
+            "Ware".to_string(),
+        ];
+        let suggestions = suggest_similar("War", &candidates, 5);
+        // "Ware" (dist 1), "Warehouse" (dist 6), "Warehouses" (dist 7).
+        // With threshold 5, only "Ware" is expected.
+        assert_eq!(suggestions, vec!["Ware"]);
+    }
+
+    #[test]
+    fn test_find_best_match() {
+        let candidates = vec![
+            "Warehouse".to_string(),
+            "Factory".to_string(),
+            "Supplier".to_string(),
+        ];
+        assert_eq!(
+            find_best_match("Warehous", &candidates, 2),
+            Some("Warehouse".to_string())
+        );
+        assert_eq!(find_best_match("XYZ", &candidates, 2), None);
+    }
+
+    #[test]
+    fn test_find_best_match_tie_alphabetical() {
+        let candidates = vec!["Apple".to_string(), "Apples".to_string()];
+        // Both are distance 1 from "Appl", should return alphabetically first
+        let result = find_best_match("Appl", &candidates, 2);
+        assert_eq!(result, Some("Apple".to_string()));
+    }
+
+    #[test]
+    fn test_unicode_support() {
+        assert_eq!(levenshtein_distance("café", "cafe"), 1);
+        assert_eq!(levenshtein_distance("北京", "北京"), 0);
+        assert_eq!(levenshtein_distance("北京", "上海"), 2);
+    }
+}

package/domainforge-core/src/error/mod.rs

@@ -0,0 +1,13 @@
+/// Error handling and diagnostics module
+///
+/// This module provides comprehensive error handling infrastructure including:
+/// - Error codes for all validation errors
+/// - Source position and range tracking
+/// - Fuzzy string matching for "did you mean?" suggestions
+/// - Multiple diagnostic output formatters (JSON, Human-readable, LSP)
+pub mod diagnostics;
+pub mod fuzzy;
+
+// Re-export commonly used types
+pub use crate::validation_error::{ErrorCode, Position, SourceRange, ValidationError};
+pub use diagnostics::{DiagnosticFormatter, HumanFormatter, JsonFormatter, LspFormatter};

package/domainforge-core/src/formatter/comments.rs

@@ -0,0 +1,223 @@
+//! Comment extraction and preservation utilities.
+//!
+//! This module handles extracting comments from source code and associating
+//! them with their corresponding declarations.
+
+use std::collections::BTreeMap;
+
+/// A comment extracted from source code.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Comment {
+    /// The comment text (without the leading //)
+    pub text: String,
+    /// Line number (1-indexed)
+    pub line: usize,
+    /// Whether this is a trailing comment (on same line as code)
+    pub is_trailing: bool,
+}
+
+/// Extracts comments from source code, preserving their positions.
+///
+/// Returns a map of line numbers to comments, where the line number
+/// indicates where the comment appears in the source.
+pub fn extract_comments(source: &str) -> BTreeMap<usize, Vec<Comment>> {
+    let mut comments: BTreeMap<usize, Vec<Comment>> = BTreeMap::new();
+
+    for (line_idx, line) in source.lines().enumerate() {
+        let line_num = line_idx + 1;
+        let trimmed = line.trim();
+
+        // Check for line comment
+        if let Some(comment_start) = trimmed.find("//") {
+            let before_comment = &line[..line.find("//").unwrap_or(0)];
+            let is_trailing = !before_comment.trim().is_empty();
+
+            let comment_text = trimmed[comment_start + 2..].trim();
+
+            comments.entry(line_num).or_default().push(Comment {
+                text: comment_text.to_string(),
+                line: line_num,
+                is_trailing,
+            });
+        }
+    }
+
+    comments
+}
+
+/// Groups comments with declarations.
+///
+/// Associates each leading comment block with the next declaration's line.
+/// Returns a map from declaration start line to its leading comments.
+pub fn associate_comments_with_lines(
+    comments: &BTreeMap<usize, Vec<Comment>>,
+    declaration_lines: &[usize],
+) -> BTreeMap<usize, Vec<Comment>> {
+    let mut associated: BTreeMap<usize, Vec<Comment>> = BTreeMap::new();
+
+    // Sort declaration lines
+    let mut decl_lines = declaration_lines.to_vec();
+    decl_lines.sort();
+
+    // For each declaration, find leading comments
+    for &decl_line in &decl_lines {
+        let mut leading_comments = Vec::new();
+
+        // Look backwards from the declaration for comment lines
+        let mut check_line = decl_line.saturating_sub(1);
+        while check_line > 0 {
+            if let Some(line_comments) = comments.get(&check_line) {
+                // Only consider non-trailing comments as leading
+                let non_trailing: Vec<_> = line_comments
+                    .iter()
+                    .filter(|c| !c.is_trailing)
+                    .cloned()
+                    .collect();
+
+                if non_trailing.is_empty() {
+                    break;
+                }
+
+                // Insert at beginning to maintain order
+                for c in non_trailing.into_iter().rev() {
+                    leading_comments.insert(0, c);
+                }
+                check_line -= 1;
+            } else {
+                break;
+            }
+        }
+
+        if !leading_comments.is_empty() {
+            associated.insert(decl_line, leading_comments);
+        }
+    }
+
+    associated
+}
+
+/// Represents a source file with comments tracked separately.
+#[derive(Debug, Clone)]
+pub struct CommentedSource {
+    /// The original source code
+    pub source: String,
+    /// Map of line numbers to comments
+    pub comments: BTreeMap<usize, Vec<Comment>>,
+    /// Leading comments to output before the file header
+    pub file_header_comments: Vec<Comment>,
+}
+
+impl CommentedSource {
+    /// Parse source code and extract comments.
+    pub fn new(source: &str) -> Self {
+        let comments = extract_comments(source);
+
+        // Find the first non-comment, non-empty line for header comments
+        let mut file_header_comments = Vec::new();
+        for (line_idx, line) in source.lines().enumerate() {
+            let line_num = line_idx + 1;
+            let trimmed = line.trim();
+
+            if trimmed.is_empty() {
+                continue;
+            }
+
+            if trimmed.starts_with("//") {
+                if let Some(line_comments) = comments.get(&line_num) {
+                    file_header_comments.extend(line_comments.iter().cloned());
+                }
+            } else {
+                // Found first non-comment line, stop
+                break;
+            }
+        }
+
+        Self {
+            source: source.to_string(),
+            comments,
+            file_header_comments,
+        }
+    }
+
+    /// Get leading comments for a specific line.
+    pub fn leading_comments_for(&self, line: usize) -> Vec<&Comment> {
+        // Look at previous lines for consecutive comments
+        let mut result = Vec::new();
+        let mut check_line = line.saturating_sub(1);
+
+        while check_line > 0 {
+            if let Some(comments) = self.comments.get(&check_line) {
+                let non_trailing: Vec<_> = comments.iter().filter(|c| !c.is_trailing).collect();
+
+                if non_trailing.is_empty() {
+                    break;
+                }
+
+                for c in non_trailing.into_iter().rev() {
+                    result.insert(0, c);
+                }
+                check_line -= 1;
+            } else {
+                break;
+            }
+        }
+
+        result
+    }
+
+    /// Check if there are any comments in the source.
+    pub fn has_comments(&self) -> bool {
+        !self.comments.is_empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_line_comments() {
+        let source = r#"
+// This is a comment
+Entity "Foo"
+"#;
+        let comments = extract_comments(source);
+        assert_eq!(comments.len(), 1);
+        let line2_comments = comments.get(&2).unwrap();
+        assert_eq!(line2_comments[0].text, "This is a comment");
+        assert!(!line2_comments[0].is_trailing);
+    }
+
+    #[test]
+    fn test_extract_trailing_comments() {
+        let source = r#"Entity "Foo" // trailing comment
+"#;
+        let comments = extract_comments(source);
+        let line1_comments = comments.get(&1).unwrap();
+        assert_eq!(line1_comments[0].text, "trailing comment");
+        assert!(line1_comments[0].is_trailing);
+    }
+
+    #[test]
+    fn test_multiple_comments() {
+        let source = r#"
+// Comment 1
+// Comment 2
+Entity "Foo"
+"#;
+        let comments = extract_comments(source);
+        assert_eq!(comments.len(), 2);
+        assert!(comments.contains_key(&2));
+        assert!(comments.contains_key(&3));
+    }
+
+    #[test]
+    fn test_commented_source() {
+        let source = r#"// File header comment
+Entity "Foo"
+"#;
+        let cs = CommentedSource::new(source);
+        assert_eq!(cs.file_header_comments.len(), 1);
+        assert_eq!(cs.file_header_comments[0].text, "File header comment");
+    }
+}

package/domainforge-core/src/formatter/config.rs

@@ -0,0 +1,114 @@
+//! Formatter configuration options.
+
+use serde::{Deserialize, Serialize};
+
+/// Style of indentation to use.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum IndentStyle {
+    /// Use spaces for indentation (default).
+    #[default]
+    Spaces,
+    /// Use tabs for indentation.
+    Tabs,
+}
+
+/// Configuration options for the SEA code formatter.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FormatConfig {
+    /// Style of indentation (spaces or tabs).
+    pub indent_style: IndentStyle,
+    /// Number of spaces per indentation level (ignored if using tabs).
+    pub indent_width: usize,
+    /// Maximum line width before wrapping (advisory).
+    pub max_line_width: usize,
+    /// Whether to ensure file ends with a newline.
+    pub trailing_newline: bool,
+    /// Whether to preserve comments in output.
+    pub preserve_comments: bool,
+    /// Whether to sort imports alphabetically.
+    pub sort_imports: bool,
+}
+
+impl Default for FormatConfig {
+    fn default() -> Self {
+        Self {
+            indent_style: IndentStyle::Spaces,
+            indent_width: 4,
+            max_line_width: 100,
+            trailing_newline: true,
+            preserve_comments: true,
+            sort_imports: true,
+        }
+    }
+}
+
+impl FormatConfig {
+    /// Create a new config with default values.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the indent style.
+    pub fn with_indent_style(mut self, style: IndentStyle) -> Self {
+        self.indent_style = style;
+        self
+    }
+
+    /// Set the indent width (for spaces).
+    pub fn with_indent_width(mut self, width: usize) -> Self {
+        self.indent_width = width;
+        self
+    }
+
+    /// Set whether to use tabs.
+    pub fn with_tabs(mut self) -> Self {
+        self.indent_style = IndentStyle::Tabs;
+        self
+    }
+
+    /// Get the string to use for one level of indentation.
+    pub fn indent_string(&self) -> String {
+        match self.indent_style {
+            IndentStyle::Spaces => " ".repeat(self.indent_width),
+            IndentStyle::Tabs => "\t".to_string(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_default_config() {
+        let config = FormatConfig::default();
+        assert_eq!(config.indent_style, IndentStyle::Spaces);
+        assert_eq!(config.indent_width, 4);
+        assert_eq!(config.max_line_width, 100);
+        assert!(config.trailing_newline);
+        assert!(config.preserve_comments);
+        assert!(config.sort_imports);
+    }
+
+    #[test]
+    fn test_indent_string_spaces() {
+        let config = FormatConfig::default().with_indent_width(2);
+        assert_eq!(config.indent_string(), "  ");
+    }
+
+    #[test]
+    fn test_indent_string_tabs() {
+        let config = FormatConfig::default().with_tabs();
+        assert_eq!(config.indent_string(), "\t");
+    }
+
+    #[test]
+    fn test_builder_pattern() {
+        let config = FormatConfig::new()
+            .with_indent_style(IndentStyle::Tabs)
+            .with_indent_width(8);
+
+        assert_eq!(config.indent_style, IndentStyle::Tabs);
+        assert_eq!(config.indent_width, 8);
+    }
+}

package/domainforge-core/src/formatter/mod.rs

@@ -0,0 +1,22 @@
+//! SEA Code Formatter
+//!
+//! This module provides functionality to format SEA-DSL source code with
+//! consistent whitespace, indentation, and styling.
+//!
+//! # Example
+//!
+//! ```rust,ignore
+//! use domainforge_core::formatter::{format, FormatConfig};
+//!
+//! let source = r#"Entity   "Foo"  in    bar"#;
+//! let formatted = format(source, FormatConfig::default()).unwrap();
+//! assert_eq!(formatted, "Entity \"Foo\" in bar\n");
+//! ```
+
+pub mod comments;
+pub mod config;
+pub mod printer;
+
+pub use comments::CommentedSource;
+pub use config::{FormatConfig, IndentStyle};
+pub use printer::{format, format_preserving_comments, FormatError};