domainforge 0.13.0

package/domainforge-core/tests/unicode_validation_tests.rs

@@ -0,0 +1,169 @@
+// Phase 16: Unicode Support Validation Tests
+use domainforge_core::parser::parse_to_graph;
+
+#[test]
+fn test_unicode_in_entity_names() {
+    // Test various Unicode characters in entity names
+    let source = r#"
+        Entity "Müller GmbH" in germany
+        Entity "北京公司" in china
+        Entity "Société Générale" in france
+        Entity "Компания" in russia
+    "#;
+
+    let result = parse_to_graph(source);
+
+    match result {
+        Ok(graph) => {
+            assert_eq!(graph.entity_count(), 4, "✅ Unicode in entity names works!");
+
+            // Verify we can find entities with Unicode names
+            let entities: Vec<_> = graph
+                .all_entities()
+                .iter()
+                .map(|e| e.name().to_string())
+                .collect();
+
+            assert!(entities.contains(&"Müller GmbH".to_string()));
+            assert!(entities.contains(&"北京公司".to_string()));
+            assert!(entities.contains(&"Société Générale".to_string()));
+            assert!(entities.contains(&"Компания".to_string()));
+        }
+        Err(e) => {
+            panic!("❌ Unicode in entity names failed: {:?}\n   Need to implement escape_sequence in grammar", e);
+        }
+    }
+}
+
+#[test]
+fn test_unicode_in_resource_names() {
+    let source = r#"
+        Resource "Schüssel" units
+        Resource "カメラ" units
+        Resource "Café" kg
+    "#;
+
+    let result = parse_to_graph(source);
+
+    match result {
+        Ok(graph) => {
+            assert_eq!(
+                graph.resource_count(),
+                3,
+                "✅ Unicode in resource names works!"
+            );
+        }
+        Err(e) => {
+            panic!("❌ Unicode in resource names failed: {:?}", e);
+        }
+    }
+}
+
+#[test]
+fn test_basic_escape_sequences_validation() {
+    // Test if basic escape sequences work or need implementation
+    let test_cases = vec![
+        (r#"Entity "Quote: \"test\"" "#, "Quote: \"test\""),
+        (r#"Entity "Line\nBreak" "#, "Line\nBreak"),
+        (r#"Entity "Tab\there" "#, "Tab\there"),
+        (r#"Entity "Back\\slash" "#, "Back\\slash"),
+    ];
+
+    let mut working = vec![];
+    let mut broken = vec![];
+
+    for (source, expected_name) in test_cases {
+        match parse_to_graph(source) {
+            Ok(graph) => {
+                let entity_name = graph
+                    .all_entities()
+                    .first()
+                    .map(|e| e.name().to_string())
+                    .unwrap_or_default();
+
+                if entity_name == expected_name {
+                    working.push(expected_name);
+                } else {
+                    broken.push(format!("{} (got: {})", expected_name, entity_name));
+                }
+            }
+            Err(_) => broken.push(expected_name.to_string()),
+        }
+    }
+
+    if !working.is_empty() {
+        println!("✅ Working escapes: {:?}", working);
+    }
+    if !broken.is_empty() {
+        println!("❌ Broken escapes: {:?}", broken);
+        println!("   Need to implement escape_sequence rule in grammar");
+    }
+
+    // Don't fail the test - this is validation only
+    // If all escapes work, that's great. If not, we document what needs implementing.
+}
+
+#[test]
+fn test_emoji_and_special_unicode() {
+    let source = r#"
+        Entity "Factory 🏭" in production
+        Entity "Warehouse 📦" in logistics
+        Resource "Money 💰" units
+    "#;
+
+    let result = parse_to_graph(source);
+
+    match result {
+        Ok(graph) => {
+            assert_eq!(graph.entity_count(), 2, "✅ Emoji in names works!");
+            assert_eq!(
+                graph.resource_count(),
+                1,
+                "✅ Emoji in resource names works!"
+            );
+        }
+        Err(e) => {
+            println!("❌ Emoji support failed: {:?}", e);
+            println!("   This is expected - emoji may need special handling");
+        }
+    }
+}
+
+#[test]
+fn test_mixed_unicode_and_ascii() {
+    let source = r#"
+        Entity "ABC Company (中文)" in business
+        Resource "Parts-零件" kg
+        Flow "Parts-零件" from "ABC Company (中文)" to "ABC Company (中文)" quantity 100
+    "#;
+
+    let result = parse_to_graph(source);
+
+    match result {
+        Ok(graph) => {
+            assert_eq!(graph.entity_count(), 1);
+            assert_eq!(graph.resource_count(), 1);
+            assert_eq!(graph.flow_count(), 1);
+            println!("✅ Mixed ASCII/Unicode works perfectly!");
+        }
+        Err(e) => {
+            panic!("❌ Mixed ASCII/Unicode failed: {:?}", e);
+        }
+    }
+}
+
+#[test]
+fn test_unicode_in_namespaces() {
+    let source = r#"
+        Entity "Company" in münchen
+        Resource "Product" kg in 北京
+    "#;
+
+    let result = parse_to_graph(source);
+
+    // Namespaces might have restrictions, so we just check if it parses
+    match result {
+        Ok(_) => println!("✅ Unicode in namespaces works!"),
+        Err(_) => println!("⚠️ Unicode in namespaces may have restrictions (this is OK)"),
+    }
+}

package/domainforge-core/tests/unit_tests.rs

@@ -0,0 +1,81 @@
+use domainforge_core::units::{Dimension, Unit, UnitError, UnitRegistry};
+use rust_decimal::Decimal;
+
+#[test]
+fn test_dimension_equality() {
+    assert_eq!(Dimension::Mass, Dimension::Mass);
+    assert_ne!(Dimension::Mass, Dimension::Volume);
+}
+
+#[test]
+fn test_unit_creation() {
+    let kg = Unit::new("kg", "kilogram", Dimension::Mass, Decimal::from(1), "kg");
+    assert_eq!(kg.symbol(), "kg");
+    assert_eq!(kg.dimension(), &Dimension::Mass);
+    assert_eq!(kg.base_factor(), Decimal::from(1));
+}
+
+#[test]
+fn test_unit_conversion() {
+    let registry = UnitRegistry::default();
+    let kg = registry.get_unit("kg").unwrap();
+    let g = registry.get_unit("g").unwrap();
+
+    // 1000g = 1kg
+    let converted = registry.convert(Decimal::from(1000), g, kg).unwrap();
+    assert_eq!(converted, Decimal::from(1));
+}
+
+#[test]
+fn test_incompatible_unit_conversion() {
+    let registry = UnitRegistry::default();
+    let kg = registry.get_unit("kg").unwrap();
+    let usd = registry.get_unit("USD").unwrap();
+
+    let result = registry.convert(Decimal::from(100), kg, usd);
+    assert!(result.is_err());
+    assert!(matches!(
+        result.unwrap_err(),
+        UnitError::IncompatibleDimensions { .. }
+    ));
+}
+
+#[test]
+fn test_currency_no_conversion() {
+    let registry = UnitRegistry::default();
+    let usd = registry.get_unit("USD").unwrap();
+    let eur = registry.get_unit("EUR").unwrap();
+
+    // Currencies should not convert without exchange rates
+    let result = registry.convert(Decimal::from(100), usd, eur);
+    assert!(result.is_err());
+}
+
+// REGRESSION TESTS
+
+#[test]
+fn test_all_registered_units_have_base() {
+    let registry = UnitRegistry::default();
+    for (symbol, unit) in registry.units().iter() {
+        let base_unit = registry.base_units().get(unit.dimension());
+        assert!(
+            base_unit.is_some(),
+            "Unit {} dimension {:?} has no base unit",
+            symbol,
+            unit.dimension()
+        );
+    }
+}
+
+#[test]
+fn test_conversion_is_reversible() {
+    let registry = UnitRegistry::default();
+    let kg = registry.get_unit("kg").unwrap();
+    let g = registry.get_unit("g").unwrap();
+
+    let original = Decimal::from(5);
+    let converted = registry.convert(original, kg, g).unwrap();
+    let back = registry.convert(converted, g, kg).unwrap();
+
+    assert_eq!(original, back);
+}

package/domainforge-core/tests/validate_tests.rs

@@ -0,0 +1,38 @@
+use domainforge_core::policy::Expression;
+use domainforge_core::policy::Policy;
+use domainforge_core::primitives::Entity;
+use domainforge_core::primitives::Flow;
+use domainforge_core::primitives::Resource;
+use domainforge_core::units::unit_from_string;
+use domainforge_core::Graph;
+use rust_decimal::Decimal;
+
+#[test]
+fn test_graph_validate_collects_violations() {
+    let mut graph = Graph::new();
+
+    let e1 = Entity::new_with_namespace("A", "default");
+    let e2 = Entity::new_with_namespace("B", "default");
+    graph.add_entity(e1.clone()).unwrap();
+    graph.add_entity(e2.clone()).unwrap();
+
+    let resource = Resource::new_with_namespace("Money", unit_from_string("USD"), "fin");
+    let resource_id = resource.id().clone();
+    graph.add_resource(resource).unwrap();
+
+    let flow = Flow::new(
+        resource_id.clone(),
+        e1.id().clone(),
+        e2.id().clone(),
+        Decimal::from(100),
+    );
+    graph.add_flow(flow).unwrap();
+
+    // This policy checks that sum of flow quantities should be less than 50 (violated)
+    let policy = Policy::new_with_namespace("check_amt", "default", Expression::literal(false));
+    graph.add_policy(policy).unwrap();
+
+    let result = graph.validate();
+    assert!(result.total_policies >= 1);
+    assert!(!result.violations.is_empty());
+}

package/domainforge-core/tests/validation_unit_mismatch_tests.rs

@@ -0,0 +1,83 @@
+//! Tests for unit mismatch validation during graph validation
+use domainforge_core::policy::Policy;
+use domainforge_core::policy::{AggregateFunction, BinaryOp, Expression};
+use domainforge_core::primitives::{Entity, Flow, Resource};
+use domainforge_core::units::unit_from_string;
+use domainforge_core::Graph;
+use rust_decimal::Decimal;
+
+#[test]
+fn test_validation_catches_unit_mismatch_in_policy() {
+    let mut graph = Graph::new();
+
+    let e1 = Entity::new_with_namespace("A", "default");
+    let e2 = Entity::new_with_namespace("B", "default");
+    graph.add_entity(e1.clone()).unwrap();
+    graph.add_entity(e2.clone()).unwrap();
+
+    // Money (Currency) resource
+    let money_resource = Resource::new_with_namespace("Money", unit_from_string("USD"), "default");
+    let money_id = money_resource.id().clone();
+    graph.add_resource(money_resource).unwrap();
+
+    // Weight (Mass) resource
+    let weight_resource = Resource::new_with_namespace("Weight", unit_from_string("kg"), "default");
+    let weight_id = weight_resource.id().clone();
+    graph.add_resource(weight_resource).unwrap();
+
+    // Add flows
+    let money_flow = Flow::new(
+        money_id.clone(),
+        e1.id().clone(),
+        e2.id().clone(),
+        Decimal::from(100),
+    );
+    graph.add_flow(money_flow).unwrap();
+
+    let weight_flow = Flow::new(
+        weight_id.clone(),
+        e1.id().clone(),
+        e2.id().clone(),
+        Decimal::from(200),
+    );
+    graph.add_flow(weight_flow).unwrap();
+
+    // Policy that attempts to compare currency sum <= mass literal (mismatched dimensions)
+    // Using the simpler aggregation_simple form to avoid comprehension parsing complexities
+    // Construct the aggregation comprehension AST directly to avoid parsing issues with raw expressions in test env
+    let predicate = Expression::binary(
+        BinaryOp::Equal,
+        Expression::member_access("f", "resource"),
+        Expression::literal("Money"),
+    );
+    let left_expr = Expression::AggregationComprehension {
+        function: AggregateFunction::Sum,
+        variable: "f".to_string(),
+        collection: Box::new(Expression::Variable("flows".to_string())),
+        window: None,
+        predicate: Box::new(predicate),
+        projection: Box::new(Expression::member_access("f", "quantity")),
+        target_unit: Some("USD".to_string()),
+    };
+    let right_expr = Expression::QuantityLiteral {
+        value: Decimal::from(100),
+        unit: "kg".to_string(),
+    };
+    let expr = Expression::binary(BinaryOp::LessThanOrEqual, left_expr, right_expr);
+    // Construct expression programmatically; avoid using raw parsing in this test
+    let policy = Policy::new("mismatch_test", expr);
+    graph.add_policy(policy).unwrap();
+
+    let result = graph.validate();
+    // Ensure at least one violation is present and the message refers to unit mismatch
+    assert!(
+        !result.violations.is_empty(),
+        "Expected a violation for unit mismatch"
+    );
+    let msg = result.violations[0].message.to_lowercase();
+    assert!(
+        msg.contains("unit") || msg.contains("mismatch"),
+        "Expected unit mismatch message, got: {}",
+        result.violations[0].message
+    );
+}

package/domainforge-core/tests/wasm_tests.rs

@@ -0,0 +1,229 @@
+#[cfg(feature = "wasm")]
+mod wasm_tests {
+    use domainforge_core::wasm::{Entity, Flow, Graph, Instance, Resource};
+    use wasm_bindgen_test::{wasm_bindgen_test, wasm_bindgen_test_configure};
+
+    wasm_bindgen_test_configure!(run_in_browser);
+
+    #[wasm_bindgen_test]
+    fn test_entity_creation() {
+        let entity = Entity::new("Warehouse".to_string(), Some("logistics".to_string()));
+        assert_eq!(entity.name(), "Warehouse");
+        assert_eq!(entity.namespace(), Some("logistics".to_string()));
+        assert!(!entity.id().is_empty());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_entity_without_namespace() {
+        let entity = Entity::new("Factory".to_string(), None);
+        assert_eq!(entity.name(), "Factory");
+        assert_eq!(entity.namespace(), None);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_entity_attributes() {
+        let mut entity = Entity::new("Store".to_string(), None);
+        let value = serde_wasm_bindgen::to_value(&serde_json::json!({"location": "NYC"})).unwrap();
+        entity.set_attribute("metadata".to_string(), value).unwrap();
+
+        let retrieved = entity.get_attribute("metadata".to_string());
+        assert!(!retrieved.is_null());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_resource_creation() {
+        let resource = Resource::new("Cameras".to_string(), "units".to_string(), None);
+        assert_eq!(resource.name(), "Cameras");
+        assert_eq!(resource.unit(), "units");
+        assert!(!resource.id().is_empty());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_resource_with_namespace() {
+        let resource = Resource::new(
+            "Steel".to_string(),
+            "kg".to_string(),
+            Some("materials".to_string()),
+        );
+        assert_eq!(resource.name(), "Steel");
+        assert_eq!(resource.unit(), "kg");
+        assert_eq!(resource.namespace(), Some("materials".to_string()));
+    }
+
+    #[wasm_bindgen_test]
+    fn test_flow_creation() {
+        let entity1 = Entity::new("Source".to_string(), None);
+        let entity2 = Entity::new("Dest".to_string(), None);
+        let resource = Resource::new("Product".to_string(), "units".to_string(), None);
+
+        let flow = Flow::new(
+            resource.id(),
+            entity1.id(),
+            entity2.id(),
+            "100".to_string(),
+            None,
+        );
+
+        assert!(flow.is_ok());
+        let flow = flow.unwrap();
+        assert_eq!(flow.quantity(), "100");
+        assert!(!flow.id().is_empty());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_instance_creation() {
+        let instance = Instance::new("warehouse_1".to_string(), "Warehouse".to_string(), None);
+
+        assert!(!instance.id().is_empty());
+        assert_eq!(instance.name(), "warehouse_1");
+        assert_eq!(instance.entity_type(), "Warehouse");
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_creation() {
+        let graph = Graph::new();
+        assert!(graph.is_empty());
+        assert_eq!(graph.entity_count(), 0);
+        assert_eq!(graph.resource_count(), 0);
+        assert_eq!(graph.flow_count(), 0);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_add_entity() {
+        let mut graph = Graph::new();
+        let entity = Entity::new("Factory".to_string(), None);
+
+        let result = graph.add_entity(&entity);
+        assert!(result.is_ok());
+        assert_eq!(graph.entity_count(), 1);
+        assert!(!graph.is_empty());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_get_entity() {
+        let mut graph = Graph::new();
+        let entity = Entity::new("Office".to_string(), None);
+        let id = entity.id();
+
+        graph.add_entity(&entity).unwrap();
+        let retrieved = graph.get_entity(id).unwrap();
+
+        assert!(retrieved.is_some());
+        let retrieved = retrieved.unwrap();
+        assert_eq!(retrieved.name(), "Office");
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_find_entity_by_name() {
+        let mut graph = Graph::new();
+        let entity = Entity::new("Distribution Center".to_string(), None);
+
+        graph.add_entity(&entity).unwrap();
+        let found_id = graph.find_entity_by_name("Distribution Center".to_string());
+
+        assert!(found_id.is_some());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_add_resource() {
+        let mut graph = Graph::new();
+        let resource = Resource::new("Materials".to_string(), "kg".to_string(), None);
+
+        let result = graph.add_resource(&resource);
+        assert!(result.is_ok());
+        assert_eq!(graph.resource_count(), 1);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_add_flow_with_validation() {
+        let mut graph = Graph::new();
+        let entity1 = Entity::new("Source".to_string(), None);
+        let entity2 = Entity::new("Target".to_string(), None);
+        let resource = Resource::new("Goods".to_string(), "units".to_string(), None);
+
+        graph.add_entity(&entity1).unwrap();
+        graph.add_entity(&entity2).unwrap();
+        graph.add_resource(&resource).unwrap();
+
+        let flow = Flow::new(
+            resource.id(),
+            entity1.id(),
+            entity2.id(),
+            "50".to_string(),
+            None,
+        )
+        .unwrap();
+
+        let result = graph.add_flow(&flow);
+        assert!(result.is_ok());
+        assert_eq!(graph.flow_count(), 1);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_flows_from() {
+        let mut graph = Graph::new();
+        let entity1 = Entity::new("Warehouse".to_string(), None);
+        let entity2 = Entity::new("Store".to_string(), None);
+        let resource = Resource::new("Items".to_string(), "units".to_string(), None);
+
+        graph.add_entity(&entity1).unwrap();
+        graph.add_entity(&entity2).unwrap();
+        graph.add_resource(&resource).unwrap();
+
+        let flow = Flow::new(
+            resource.id(),
+            entity1.id(),
+            entity2.id(),
+            "100".to_string(),
+            None,
+        )
+        .unwrap();
+        graph.add_flow(&flow).unwrap();
+
+        let flows = graph.flows_from(entity1.id());
+        assert!(flows.is_ok());
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_parse_simple() {
+        let source = r#"
+Entity "Warehouse" in logistics
+Resource "Cameras" units
+"#;
+
+        let result = Graph::parse(source.to_string());
+        assert!(result.is_ok());
+
+        let graph = result.unwrap();
+        assert_eq!(graph.entity_count(), 1);
+        assert_eq!(graph.resource_count(), 1);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_parse_with_flow() {
+        let source = r#"
+Entity "Warehouse" in logistics
+Entity "Factory" in manufacturing
+Resource "Materials" kg
+Flow "Materials" from "Warehouse" to "Factory" quantity 500
+"#;
+
+        let result = Graph::parse(source.to_string());
+        assert!(result.is_ok());
+
+        let graph = result.unwrap();
+        assert_eq!(graph.entity_count(), 2);
+        assert_eq!(graph.resource_count(), 1);
+        assert_eq!(graph.flow_count(), 1);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_graph_serialization() {
+        let mut graph = Graph::new();
+        let entity = Entity::new("TestEntity".to_string(), None);
+        graph.add_entity(&entity).unwrap();
+
+        let json_result = graph.to_json();
+        assert!(json_result.is_ok());
+    }
+}

package/domainforge-python/CHANGELOG-python.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [0.13.0](https://github.com/GodSpeedAI/DomainForge/compare/domainforge-v0.12.0...domainforge-v0.13.0) (2026-06-20)
+
+
+### ⚠ BREAKING CHANGES
+
+* **repo:** packages renamed sea-core -> domainforge-core (crates.io), sea-dsl -> domainforge (PyPI), @godspeedai/sea -> @godspeedai/domainforge (npm); the `sea` CLI binary is now `domainforge`. See the per-package MIGRATING.md files.
+
+### Features
+
+* **repo:** document sea to domainforge migration ([#101](https://github.com/GodSpeedAI/DomainForge/issues/101)) ([f5182b6](https://github.com/GodSpeedAI/DomainForge/commit/f5182b6a014f7ecd7ae429de76eb14abe01d9ed6))

package/domainforge-python/MIGRATING.md

@@ -0,0 +1,24 @@
+# Migrating from `sea-dsl` to `domainforge` (Python)
+
+The Python package was renamed on PyPI and the import module changed:
+
+| Before               | After              |
+|----------------------|--------------------|
+| `sea-dsl` (PyPI)     | `domainforge`      |
+| `import sea_dsl`     | `import domainforge` |
+
+## Install
+
+```bash
+# old: pip install sea-dsl
+pip install domainforge
+```
+
+## Import
+
+```python
+# old: from sea_dsl import Graph, Entity
+from domainforge import Graph, Entity
+```
+
+The API surface is otherwise unchanged.