domainforge 0.13.0

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

@@ -0,0 +1,9 @@
+pub mod export;
+pub mod import;
+pub mod models;
+pub mod sbvr_import;
+
+pub use export::export;
+pub use import::import;
+pub use models::{CalmModel, CalmNode, CalmRelationship};
+pub use sbvr_import::import_sbvr_xmi;

package/domainforge-core/src/calm/models.rs

@@ -0,0 +1,108 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CalmModel {
+    #[serde(default = "default_version")]
+    pub version: String,
+
+    pub metadata: CalmMetadata,
+    pub nodes: Vec<CalmNode>,
+    pub relationships: Vec<CalmRelationship>,
+}
+
+fn default_version() -> String {
+    "2.0".to_string()
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CalmMetadata {
+    #[serde(rename = "sea:exported")]
+    pub sea_exported: bool,
+
+    #[serde(rename = "sea:version")]
+    pub sea_version: String,
+
+    #[serde(rename = "sea:timestamp", skip_serializing_if = "Option::is_none")]
+    pub sea_timestamp: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CalmNode {
+    #[serde(rename = "unique-id")]
+    pub unique_id: String,
+
+    #[serde(rename = "node-type")]
+    pub node_type: NodeType,
+
+    pub name: String,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub namespace: Option<String>,
+
+    #[serde(default)]
+    pub metadata: HashMap<String, Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum NodeType {
+    Actor,
+    Location,
+    Resource,
+    Instance,
+    Constraint,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CalmRelationship {
+    #[serde(rename = "unique-id")]
+    pub unique_id: String,
+
+    #[serde(rename = "relationship-type")]
+    pub relationship_type: RelationshipType,
+
+    pub parties: Parties,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum RelationshipType {
+    Flow { flow: FlowDetails },
+    Simple(String),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FlowDetails {
+    pub resource: String,
+    pub quantity: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Parties {
+    SourceDestination { source: String, destination: String },
+    OwnerOwned { owner: String, owned: String },
+}
+
+impl CalmModel {
+    pub fn new() -> Self {
+        CalmModel {
+            version: "2.0".to_string(),
+            metadata: CalmMetadata {
+                sea_exported: true,
+                sea_version: crate::VERSION.to_string(),
+                sea_timestamp: None,
+            },
+            nodes: Vec::new(),
+            relationships: Vec::new(),
+        }
+    }
+}
+
+impl Default for CalmModel {
+    fn default() -> Self {
+        Self::new()
+    }
+}

package/domainforge-core/src/calm/sbvr_import.rs

@@ -0,0 +1,9 @@
+use crate::graph::Graph;
+use crate::sbvr::SbvrModel;
+
+pub fn import_sbvr_xmi(xmi: &str) -> Result<Graph, String> {
+    let model = SbvrModel::from_xmi(xmi).map_err(|e| format!("Failed to parse SBVR XMI: {}", e))?;
+    model
+        .to_graph()
+        .map_err(|e| format!("Failed to convert SBVR to Graph: {}", e))
+}

package/domainforge-core/src/cli/authority.rs

@@ -0,0 +1,149 @@
+//! CLI module for the `sea authority` command.
+//!
+//! Provides authority evaluation from the command line.
+
+use crate::authority::{
+    AuthorityEnvironment, AuthorityEnvironmentConfig, AuthorityRequest, FactEnvelope,
+};
+use clap::Args;
+
+/// Arguments for the `authority` subcommand.
+#[derive(Args, Debug)]
+pub struct AuthorityArgs {
+    /// Path to authority environment config JSON file
+    #[arg(help = "Path to authority environment config JSON")]
+    pub config: String,
+
+    /// Path to authority request JSON file
+    #[arg(help = "Path to authority request JSON")]
+    pub request: String,
+
+    /// Path to facts JSON file (optional)
+    #[arg(long, value_name = "FILE", help = "Path to facts JSON file")]
+    pub facts: Option<String>,
+
+    /// Output result as JSON
+    #[arg(long, help = "Output as JSON object")]
+    pub json: bool,
+}
+
+/// Result of authority evaluation for JSON output.
+#[derive(serde::Serialize)]
+struct AuthorityResult {
+    decision_id: String,
+    request_id: String,
+    final_decision: String,
+    reason_code: String,
+    trace_ref: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    operator_action_hint: Option<String>,
+}
+
+/// Run the authority command.
+pub fn run(args: AuthorityArgs) -> anyhow::Result<()> {
+    run_with_writer(args, &mut std::io::stdout())
+}
+
+/// Run the authority command with a specific writer for output capture.
+pub fn run_with_writer<W: std::io::Write>(
+    args: AuthorityArgs,
+    mut writer: W,
+) -> anyhow::Result<()> {
+    // Validate and canonicalize user-supplied paths
+    let config_path = std::path::Path::new(&args.config);
+    if !config_path.exists() {
+        return Err(anyhow::anyhow!(
+            "Config file '{}' does not exist",
+            args.config
+        ));
+    }
+
+    let request_path = std::path::Path::new(&args.request);
+    if !request_path.exists() {
+        return Err(anyhow::anyhow!(
+            "Request file '{}' does not exist",
+            args.request
+        ));
+    }
+
+    if let Some(ref facts) = args.facts {
+        let facts_path = std::path::Path::new(facts);
+        if !facts_path.exists() {
+            return Err(anyhow::anyhow!("Facts file '{}' does not exist", facts));
+        }
+    }
+
+    // Load config
+    let config_str = std::fs::read_to_string(&args.config)
+        .map_err(|e| anyhow::anyhow!("Failed to read config file '{}': {}", args.config, e))?;
+    let config: AuthorityEnvironmentConfig = serde_json::from_str(&config_str)
+        .map_err(|e| anyhow::anyhow!("Failed to parse config JSON: {}", e))?;
+
+    // Create and validate environment
+    let mut env = AuthorityEnvironment::new(config)
+        .map_err(|e| anyhow::anyhow!("Failed to create authority environment: {}", e))?;
+    env.validate()
+        .map_err(|e| anyhow::anyhow!("Environment validation failed: {}", e))?;
+
+    // Load request
+    let request_str = std::fs::read_to_string(&args.request)
+        .map_err(|e| anyhow::anyhow!("Failed to read request file '{}': {}", args.request, e))?;
+    let request: AuthorityRequest = serde_json::from_str(&request_str)
+        .map_err(|e| anyhow::anyhow!("Failed to parse request JSON: {}", e))?;
+
+    // Load facts (optional)
+    let facts: Vec<FactEnvelope> = if let Some(ref facts_path) = args.facts {
+        let facts_str = std::fs::read_to_string(facts_path)
+            .map_err(|e| anyhow::anyhow!("Failed to read facts file '{}': {}", facts_path, e))?;
+        serde_json::from_str(&facts_str)
+            .map_err(|e| anyhow::anyhow!("Failed to parse facts JSON: {}", e))?
+    } else {
+        vec![]
+    };
+
+    // Evaluate
+    let (trace, decision) = env
+        .evaluate(&request, &facts)
+        .map_err(|e| anyhow::anyhow!("Authority evaluation failed: {}", e))?;
+
+    if args.json {
+        let result = AuthorityResult {
+            decision_id: decision.decision_id,
+            request_id: decision.request_id,
+            final_decision: format!("{:?}", decision.final_decision),
+            reason_code: decision.reason_code,
+            trace_ref: decision.trace_ref,
+            operator_action_hint: decision.operator_action_hint,
+        };
+        let json = serde_json::to_string_pretty(&result)
+            .map_err(|e| anyhow::anyhow!("Failed to serialize result: {}", e))?;
+        writeln!(writer, "{}", json)?;
+    } else {
+        writeln!(writer, "Authority Decision")?;
+        writeln!(writer, "  Decision ID:  {}", decision.decision_id)?;
+        writeln!(writer, "  Request ID:   {}", decision.request_id)?;
+        writeln!(writer, "  Decision:     {:?}", decision.final_decision)?;
+        writeln!(writer, "  Reason:       {}", decision.reason_code)?;
+        writeln!(writer, "  Trace Ref:    {}", decision.trace_ref)?;
+        if let Some(ref hint) = decision.operator_action_hint {
+            writeln!(writer, "  Action Hint:  {}", hint)?;
+        }
+        writeln!(writer)?;
+        writeln!(writer, "Trace Details")?;
+        writeln!(
+            writer,
+            "  Semantics:    {} ({})",
+            trace.resolver_semantics_version, trace.resolver_semantics_hash
+        )?;
+        writeln!(
+            writer,
+            "  Profile:      {} ({})",
+            trace.specificity_profile_id, trace.specificity_profile_hash
+        )?;
+        writeln!(writer, "  Packs:        {:?}", trace.pack_hashes)?;
+        writeln!(writer, "  Claim Level:  {:?}", trace.claim_level)?;
+        writeln!(writer, "  Created:      {}", trace.created_at)?;
+    }
+
+    Ok(())
+}

package/domainforge-core/src/cli/format.rs

@@ -0,0 +1,85 @@
+use crate::formatter::{format, FormatConfig, IndentStyle};
+use anyhow::{Context, Result};
+use clap::Parser;
+use std::fs::{read_to_string, write};
+use std::io::{self, Write};
+use std::path::PathBuf;
+
+#[derive(Parser)]
+pub struct FormatArgs {
+    /// SEA file to format
+    pub file: PathBuf,
+
+    /// Output file (defaults to stdout)
+    #[arg(long)]
+    pub out: Option<PathBuf>,
+
+    /// Number of spaces per indentation level
+    #[arg(long, default_value = "4")]
+    pub indent_width: usize,
+
+    /// Use tabs instead of spaces for indentation
+    #[arg(long)]
+    pub use_tabs: bool,
+
+    /// Check if file would be reformatted (exit 1 if changes needed)
+    #[arg(long)]
+    pub check: bool,
+
+    /// Sort imports alphabetically
+    #[arg(long, default_value = "true")]
+    pub sort_imports: bool,
+}
+
+pub fn run(args: FormatArgs) -> Result<()> {
+    let source = read_to_string(&args.file)
+        .with_context(|| format!("Failed to read file {}", args.file.display()))?;
+
+    let config = FormatConfig {
+        indent_width: args.indent_width,
+        indent_style: if args.use_tabs {
+            IndentStyle::Tabs
+        } else {
+            IndentStyle::Spaces
+        },
+        sort_imports: args.sort_imports,
+        ..Default::default()
+    };
+
+    let formatted = format(&source, config)
+        .map_err(|e| anyhow::anyhow!("Format failed for {}: {}", args.file.display(), e))?;
+
+    if args.check {
+        // Check mode: exit with error if file would change
+        if source != formatted {
+            // Show diff summary
+            let source_lines = source.lines().count();
+            let formatted_lines = formatted.lines().count();
+            eprintln!(
+                "Would reformat {} ({} -> {} lines)",
+                args.file.display(),
+                source_lines,
+                formatted_lines
+            );
+            anyhow::bail!("File would be reformatted: {}", args.file.display());
+        } else {
+            println!("{}: already formatted", args.file.display());
+        }
+    } else if let Some(out_path) = args.out {
+        // Write to specified output file
+        write(&out_path, &formatted)
+            .with_context(|| format!("Failed to write to {}", out_path.display()))?;
+        println!(
+            "Formatted {} -> {}",
+            args.file.display(),
+            out_path.display()
+        );
+    } else {
+        // Write to stdout
+        io::stdout()
+            .write_all(formatted.as_bytes())
+            .context("Failed to write to stdout")?;
+    }
+
+    Ok(())
+}

package/domainforge-core/src/cli/import.rs

@@ -0,0 +1,133 @@
+use crate::import_kg_turtle;
+use anyhow::{Context, Result};
+use clap::{Parser, ValueEnum};
+use std::fs::read_to_string;
+use std::path::PathBuf;
+
+#[cfg(feature = "shacl")]
+use crate::kg_import::ImportError;
+
+#[derive(Parser)]
+pub struct ImportArgs {
+    #[arg(long, value_enum)]
+    pub format: ImportFormat,
+
+    pub file: PathBuf,
+}
+
+#[derive(ValueEnum, Clone, Debug, Copy)]
+pub enum ImportFormat {
+    Sbvr,
+    Kg,
+}
+
+/// Helper function to print import success message with graph statistics
+fn print_import_success(graph: &crate::Graph, format_desc: &str) {
+    println!(
+        "Imported {} to Graph: entities={} resources={} flows={}",
+        format_desc,
+        graph.entity_count(),
+        graph.resource_count(),
+        graph.flow_count()
+    );
+}
+
+pub fn run(args: ImportArgs) -> Result<()> {
+    let source = read_to_string(&args.file)
+        .with_context(|| format!("Failed to read file {}", args.file.display()))?;
+
+    match args.format {
+        ImportFormat::Sbvr => match crate::SbvrModel::from_xmi(&source) {
+            Ok(model) => match model.to_graph() {
+                Ok(graph) => {
+                    print_import_success(&graph, "SBVR");
+                    Ok(())
+                }
+                Err(e) => Err(anyhow::anyhow!("Failed to convert SBVR to Graph: {}", e)),
+            },
+            Err(e) => Err(anyhow::anyhow!("Failed to parse SBVR XMI: {}", e)),
+        },
+        ImportFormat::Kg => {
+            let src_trim = source.trim_start();
+            // More specific RDF/XML detection: check for XML declaration or RDF namespace
+            let is_likely_rdfxml = src_trim.starts_with("<?xml")
+                || src_trim.starts_with("<rdf:")
+                || src_trim.starts_with("<rdf ")
+                || src_trim.contains("xmlns:rdf");
+
+            if is_likely_rdfxml {
+                #[cfg(feature = "shacl")]
+                {
+                    match crate::import_kg_rdfxml(&source) {
+                        Ok(graph) => {
+                            print_import_success(&graph, "KG (RDF/XML)");
+                            Ok(())
+                        }
+                        Err(err_rdf) => match err_rdf {
+                            ImportError::ShaclValidation(msg) => Err(anyhow::anyhow!("{}", msg)),
+                            other => {
+                                let err_rdf_msg = other.to_string();
+                                match import_kg_turtle(&source) {
+                                    Ok(graph) => {
+                                        print_import_success(&graph, "KG (Turtle)");
+                                        Ok(())
+                                    }
+                                    Err(err_turtle) => Err(anyhow::anyhow!(
+                                        "Failed to import KG as RDF/XML: {}; as Turtle: {}",
+                                        err_rdf_msg,
+                                        err_turtle
+                                    )),
+                                }
+                            }
+                        },
+                    }
+                }
+                #[cfg(not(feature = "shacl"))]
+                {
+                    match import_kg_turtle(&source) {
+                        Ok(graph) => {
+                            print_import_success(&graph, "KG (Turtle)");
+                            Ok(())
+                        }
+                        Err(err) => {
+                            Err(anyhow::anyhow!("Failed to import KG: {}. Consider enabling the 'shacl' feature for RDF/XML support.", err))
+                        }
+                    }
+                }
+            } else {
+                match import_kg_turtle(&source) {
+                    Ok(graph) => {
+                        print_import_success(&graph, "KG (Turtle)");
+                        Ok(())
+                    }
+                    Err(err_turtle) => {
+                        #[cfg(feature = "shacl")]
+                        {
+                            match crate::import_kg_rdfxml(&source) {
+                                Ok(graph) => {
+                                    print_import_success(&graph, "KG (RDF/XML)");
+                                    Ok(())
+                                }
+                                Err(err_rdf) => {
+                                    match err_rdf {
+                                        ImportError::ShaclValidation(msg) => {
+                                            Err(anyhow::anyhow!("{}", msg))
+                                        }
+                                        other => {
+                                            let err_rdf_msg = other.to_string();
+                                            Err(anyhow::anyhow!("Failed to import KG as Turtle: {}; and as RDF/XML: {}", err_turtle, err_rdf_msg))
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        #[cfg(not(feature = "shacl"))]
+                        {
+                            Err(anyhow::anyhow!("Failed to import KG (Turtle): {}. To try RDF/XML, enable feature 'shacl' in the build.", err_turtle))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+use clap::{Parser, Subcommand, ValueEnum};
+
+pub mod authority;
+pub mod format;
+pub mod import;
+pub mod normalize;
+pub mod pack;
+pub mod parse;
+pub mod project;
+pub mod registry;
+pub mod test;
+pub mod validate;
+pub mod validate_kg;
+
+#[derive(Parser)]
+#[command(name = "domainforge", version, about = "SEA DSL CLI")]
+pub struct Cli {
+    #[command(subcommand)]
+    pub command: Commands,
+
+    #[arg(long, global = true, conflicts_with = "quiet")]
+    pub verbose: bool,
+
+    #[arg(long, global = true, conflicts_with = "verbose")]
+    pub quiet: bool,
+
+    #[arg(long, global = true, value_enum, default_value_t = ColorChoice::Auto)]
+    pub color: ColorChoice,
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+    /// Parse SEA files and output AST or Graph
+    Parse(parse::ParseArgs),
+    /// Validate SEA files
+    Validate(validate::ValidateArgs),
+    /// Import from other formats
+    Import(import::ImportArgs),
+    /// Project/Export to other formats
+    Project(project::ProjectArgs),
+    /// Format SEA files
+    #[command(name = "format", alias = "fmt")]
+    Format(format::FormatArgs),
+    /// Run tests
+    Test(test::TestArgs),
+    /// Validate Knowledge Graph files
+    #[command(name = "validate-kg")]
+    ValidateKg(validate_kg::ValidateKgArgs),
+    /// Normalize a policy expression
+    Normalize(normalize::NormalizeArgs),
+    /// Registry management commands
+    Registry(registry::RegistryArgs),
+    /// Evaluate authority decisions
+    Authority(authority::AuthorityArgs),
+    /// Semantic pack management commands
+    Pack(pack::PackArgs),
+}
+
+#[derive(ValueEnum, Clone, Debug, Copy)]
+pub enum ColorChoice {
+    Auto,
+    Always,
+    Never,
+}