domainforge 0.13.0

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

@@ -0,0 +1,112 @@
+//! Parse SEA files and output AST or Graph JSON.
+//!
+//! This command parses a SEA DSL file and outputs the result in the specified format.
+//! Use `--format json` to get structured JSON output suitable for tooling.
+
+use anyhow::{Context, Result};
+use clap::{Args, ValueEnum};
+use std::fs;
+use std::path::PathBuf;
+
+#[derive(Args)]
+pub struct ParseArgs {
+    /// Input SEA file to parse
+    #[arg(required = true)]
+    pub input: PathBuf,
+
+    /// Output format
+    #[arg(long, value_enum, default_value_t = ParseFormat::Human)]
+    pub format: ParseFormat,
+
+    /// Output file (stdout if not specified)
+    #[arg(long, short)]
+    pub out: Option<PathBuf>,
+
+    /// Output AST instead of Graph (preserves source structure and line numbers)
+    #[arg(long)]
+    pub ast: bool,
+
+    /// Output AST v3 (alias for --ast)
+    #[arg(long)]
+    pub ast_v3: bool,
+}
+
+#[derive(ValueEnum, Clone, Debug, Copy, Default)]
+pub enum ParseFormat {
+    /// Human-readable summary
+    #[default]
+    Human,
+    /// JSON output
+    Json,
+}
+
+pub fn run(args: ParseArgs) -> Result<()> {
+    let source = fs::read_to_string(&args.input)
+        .with_context(|| format!("Failed to read file: {}", args.input.display()))?;
+
+    let output = match (args.ast || args.ast_v3, args.format) {
+        // AST output (uses schema types for stable JSON format)
+        (true, ParseFormat::Json) => {
+            let internal_ast =
+                crate::parser::parse(&source).map_err(|e| anyhow::anyhow!("Parse error: {}", e))?;
+            let schema_ast: crate::parser::ast_schema::Ast = internal_ast.into();
+            serde_json::to_string_pretty(&schema_ast).context("Failed to serialize AST to JSON")?
+        }
+        (true, ParseFormat::Human) => {
+            let ast =
+                crate::parser::parse(&source).map_err(|e| anyhow::anyhow!("Parse error: {}", e))?;
+            format!(
+                "AST parsed successfully: {}\n\
+                 Namespace: {}\n\
+                 Version: {}\n\
+                 Declarations: {}",
+                args.input.display(),
+                ast.metadata.namespace.as_deref().unwrap_or("(none)"),
+                ast.metadata.version.as_deref().unwrap_or("(none)"),
+                ast.declarations.len()
+            )
+        }
+        // Graph output (default)
+        (false, ParseFormat::Json) => {
+            let graph = crate::parser::parse_to_graph(&source)
+                .map_err(|e| anyhow::anyhow!("Parse error: {}", e))?;
+            serde_json::to_string_pretty(&graph).context("Failed to serialize Graph to JSON")?
+        }
+        (false, ParseFormat::Human) => {
+            let graph = crate::parser::parse_to_graph(&source)
+                .map_err(|e| anyhow::anyhow!("Parse error: {}", e))?;
+            format!(
+                "Graph parsed successfully: {}\n\
+                 Entities: {}\n\
+                 Resources: {}\n\
+                 Flows: {}\n\
+                 Roles: {}\n\
+                 Relations: {}\n\
+                 Instances: {}\n\
+                 Policies: {}",
+                args.input.display(),
+                graph.entity_count(),
+                graph.resource_count(),
+                graph.flow_count(),
+                graph.role_count(),
+                graph.relation_count(),
+                graph.instance_count(),
+                graph.pattern_count()
+            )
+        }
+    };
+
+    // Write output
+    match args.out {
+        Some(path) => {
+            fs::write(&path, &output)
+                .with_context(|| format!("Failed to write to: {}", path.display()))?;
+            eprintln!("Wrote output to: {}", path.display());
+        }
+        None => {
+            println!("{}", output);
+        }
+    }
+
+    Ok(())
+}

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

@@ -0,0 +1,294 @@
+use crate::parser::{parse_to_graph_with_options, ParseOptions};
+use crate::projection::protobuf::{CompatibilityMode, SchemaHistory};
+use crate::projection::ProtobufEngine;
+use crate::NamespaceRegistry;
+use anyhow::{Context, Result};
+use clap::{Parser, ValueEnum};
+use std::fs::{read_to_string, write};
+use std::path::{Path, PathBuf};
+
+#[derive(Parser)]
+pub struct ProjectArgs {
+    #[arg(long, value_enum)]
+    pub format: ProjectFormat,
+
+    /// Optional namespace filter (project only entities from this namespace)
+    #[arg(long)]
+    pub namespace: Option<String>,
+
+    /// Protobuf package name (for protobuf format)
+    #[arg(long, default_value = "sea.generated")]
+    pub package: String,
+
+    /// Include governance messages (for protobuf format)
+    #[arg(long)]
+    pub include_governance: bool,
+
+    /// Generate gRPC service definitions from Flow patterns (protobuf only)
+    #[arg(long)]
+    pub include_services: bool,
+
+    /// Schema compatibility mode: additive, backward, or breaking (protobuf only)
+    #[arg(long, value_enum, default_value = "backward")]
+    pub compatibility: CliCompatibilityMode,
+
+    /// Directory to store schema history for compatibility checking (protobuf only)
+    #[arg(long)]
+    pub schema_history: Option<PathBuf>,
+
+    /// Automatically apply fixes (add reserved fields) for backward compatibility
+    #[arg(long)]
+    pub apply_fixes: bool,
+
+    /// Run 'buf lint' on the generated output
+    #[arg(long)]
+    pub buf_lint: bool,
+
+    /// Run 'buf breaking' check against previous version
+    #[arg(long)]
+    pub buf_breaking: bool,
+
+    /// Run 'buf generate' to build code artifacts
+    #[arg(long)]
+    pub buf_generate: bool,
+
+    /// Generate multiple files (one per namespace) instead of a single file
+    #[arg(long)]
+    pub multi_file: bool,
+
+    pub input: PathBuf,
+    pub output: PathBuf,
+}
+
+#[derive(ValueEnum, Clone, Debug, Copy)]
+pub enum ProjectFormat {
+    Calm,
+    Kg,
+    Protobuf,
+    Proto, // alias for protobuf
+}
+
+#[derive(ValueEnum, Clone, Debug, Copy, Default)]
+pub enum CliCompatibilityMode {
+    /// Only additions allowed - strictest mode for public APIs
+    Additive,
+    /// Removals become reserved fields - default for internal APIs
+    #[default]
+    Backward,
+    /// All changes allowed - for breaking releases
+    Breaking,
+}
+
+impl From<CliCompatibilityMode> for CompatibilityMode {
+    fn from(mode: CliCompatibilityMode) -> Self {
+        match mode {
+            CliCompatibilityMode::Additive => CompatibilityMode::Additive,
+            CliCompatibilityMode::Backward => CompatibilityMode::Backward,
+            CliCompatibilityMode::Breaking => CompatibilityMode::Breaking,
+        }
+    }
+}
+
+pub fn run(args: ProjectArgs) -> Result<()> {
+    let source = read_to_string(&args.input)
+        .with_context(|| format!("Failed to read input file {}", args.input.display()))?;
+
+    // Parse input
+    let registry =
+        NamespaceRegistry::discover(&args.input).context("discovering namespace registry")?;
+    let default_namespace = registry
+        .as_ref()
+        .and_then(|reg| reg.namespace_for(&args.input).map(|ns| ns.to_string()));
+    let options = ParseOptions {
+        default_namespace: default_namespace.clone(),
+        namespace_registry: registry.clone(),
+        entry_path: Some(args.input.clone()),
+        ..Default::default()
+    };
+    let graph = parse_to_graph_with_options(&source, &options)
+        .map_err(|e| anyhow::anyhow!("Parse failed for {}: {}", args.input.display(), e))?;
+
+    match args.format {
+        ProjectFormat::Calm => {
+            let value = crate::calm::export(&graph)
+                .map_err(|e| anyhow::anyhow!("Failed to export to CALM: {}", e))?;
+            let json =
+                serde_json::to_string_pretty(&value).context("Failed to serialize CALM JSON")?;
+            write(&args.output, json)
+                .with_context(|| format!("Failed to write output to {}", args.output.display()))?;
+            println!("Projected to CALM: {}", args.output.display());
+        }
+        ProjectFormat::Kg => {
+            let kg = crate::KnowledgeGraph::from_graph(&graph)
+                .map_err(|e| anyhow::anyhow!("Failed to convert to Knowledge Graph: {}", e))?;
+
+            let output_str = if args
+                .output
+                .extension()
+                .and_then(|ext| ext.to_str())
+                .is_some_and(|ext| {
+                    ext.eq_ignore_ascii_case("xml") || ext.eq_ignore_ascii_case("rdf")
+                }) {
+                kg.to_rdf_xml()
+            } else {
+                kg.to_turtle()
+            };
+
+            write(&args.output, output_str)
+                .with_context(|| format!("Failed to write output to {}", args.output.display()))?;
+            println!("Projected to KG: {}", args.output.display());
+        }
+        ProjectFormat::Protobuf | ProjectFormat::Proto => {
+            let namespace_filter = args.namespace.as_deref().unwrap_or("");
+            let projection_name = args
+                .input
+                .file_stem()
+                .and_then(|s| s.to_str())
+                .unwrap_or("projection");
+
+            if args.multi_file {
+                if args.schema_history.is_some() {
+                    eprintln!(
+                        "Warning: --schema-history is currently ignored in --multi-file mode."
+                    );
+                }
+
+                if !args.output.exists() {
+                    std::fs::create_dir_all(&args.output).with_context(|| {
+                        format!(
+                            "Failed to create output directory {}",
+                            args.output.display()
+                        )
+                    })?;
+                } else if !args.output.is_dir() {
+                    return Err(anyhow::anyhow!(
+                        "Output path must be a directory for --multi-file projection"
+                    ));
+                }
+
+                let files = ProtobufEngine::project_multi_file(
+                    &graph,
+                    &args.package,
+                    args.include_governance,
+                    args.include_services,
+                );
+
+                for (rel_path, proto) in &files {
+                    let abs_path = args.output.join(rel_path);
+                    crate::projection::protobuf::validate_output_path(&args.output, &abs_path)
+                        .map_err(|e| anyhow::anyhow!("{}", e))?;
+                    if let Some(parent) = abs_path.parent() {
+                        std::fs::create_dir_all(parent)?;
+                    }
+
+                    let content = proto.to_proto_string();
+                    write(&abs_path, content)
+                        .with_context(|| format!("Failed to write {}", abs_path.display()))?;
+                }
+
+                println!(
+                    "Projected to Protobuf (Multi-file): {}",
+                    args.output.display()
+                );
+                println!("  Files: {}", files.len());
+                println!("  Base Package: {}", args.package);
+            } else {
+                let mut proto_file = ProtobufEngine::project_with_full_options(
+                    &graph,
+                    namespace_filter,
+                    &args.package,
+                    projection_name,
+                    args.include_governance,
+                    args.include_services,
+                );
+
+                // Handle compatibility checking if schema history is provided
+                if let Some(ref history_dir) = args.schema_history {
+                    let history = SchemaHistory::new(history_dir);
+                    let mode: CompatibilityMode = args.compatibility.into();
+
+                    let result = history
+                        .check_and_update(&mut proto_file, mode, args.apply_fixes)
+                        .map_err(|e| anyhow::anyhow!("Compatibility check failed: {}", e))?;
+
+                    // Print compatibility report
+                    if result.has_violations() {
+                        eprintln!("\n{}", result.to_report());
+                    }
+
+                    // Fail if not compatible (unless in breaking mode)
+                    if !result.is_compatible {
+                        return Err(anyhow::anyhow!(
+                            "Schema evolution is not compatible in {} mode. Use --compatibility breaking to force, or --apply-fixes to auto-fix.",
+                            mode
+                        ));
+                    }
+
+                    if result.has_violations() {
+                        println!(
+                            "  Compatibility: {} (with {} warnings)",
+                            mode,
+                            result.violations.len()
+                        );
+                    } else {
+                        println!("  Compatibility: {} (clean)", mode);
+                    }
+                }
+
+                let proto_string = proto_file.to_proto_string();
+                write(&args.output, &proto_string).with_context(|| {
+                    format!("Failed to write output to {}", args.output.display())
+                })?;
+                println!("Projected to Protobuf: {}", args.output.display());
+                println!("  Package: {}", args.package);
+                println!("  Messages: {}", proto_file.messages.len());
+                if !proto_file.services.is_empty() {
+                    println!(
+                        "  Services: {} ({} methods)",
+                        proto_file.services.len(),
+                        proto_file
+                            .services
+                            .iter()
+                            .map(|s| s.methods.len())
+                            .sum::<usize>()
+                    );
+                }
+            }
+
+            // Buf integration
+            if args.buf_lint || args.buf_breaking || args.buf_generate {
+                use crate::projection::buf::BufIntegration;
+                let buf = BufIntegration::new();
+                let output_dir = if args.multi_file {
+                    &args.output
+                } else {
+                    args.output.parent().unwrap_or(Path::new("."))
+                };
+
+                if args.buf_lint {
+                    print!("  Running buf lint... ");
+                    match buf.lint(output_dir) {
+                        Ok(result) => {
+                            if result.success {
+                                println!("clean");
+                            } else {
+                                println!("issues found:");
+                                println!("{}", result.raw_output);
+                            }
+                        }
+                        Err(e) => println!("failed: {}", e),
+                    }
+                }
+
+                if args.buf_breaking {
+                    if let Some(history) = args.schema_history {
+                        print!("  Running buf breaking check... ");
+                        println!("(checking against {})", history.display());
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

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

@@ -0,0 +1,41 @@
+use crate::registry::NamespaceRegistry;
+use clap::{Args, Subcommand};
+use std::path::PathBuf;
+
+#[derive(Debug, Args)]
+pub struct RegistryArgs {
+    #[command(subcommand)]
+    pub command: RegistryCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum RegistryCommands {
+    /// Resolve the namespace for a file
+    Resolve(ResolveArgs),
+}
+
+#[derive(Debug, Args)]
+pub struct ResolveArgs {
+    /// Fail if multiple namespaces match with equal specificity
+    #[arg(long)]
+    pub fail_on_ambiguity: bool,
+
+    /// The file path to resolve
+    pub file: PathBuf,
+}
+
+pub fn run(args: RegistryArgs) -> anyhow::Result<()> {
+    match args.command {
+        RegistryCommands::Resolve(resolve_args) => run_resolve(resolve_args),
+    }
+}
+
+fn run_resolve(args: ResolveArgs) -> anyhow::Result<()> {
+    let path = args.file;
+    let registry = NamespaceRegistry::discover(&path)?
+        .ok_or_else(|| anyhow::anyhow!("No .sea-registry.toml found"))?;
+
+    let namespace = registry.namespace_for_with_options(&path, args.fail_on_ambiguity)?;
+    println!("{}", namespace);
+    Ok(())
+}

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

@@ -0,0 +1,12 @@
+use anyhow::Result;
+use clap::Parser;
+
+#[derive(Parser)]
+pub struct TestArgs {
+    pub pattern: String,
+}
+
+pub fn run(args: TestArgs) -> Result<()> {
+    println!("Test runner not yet implemented. Pattern: {}", args.pattern);
+    Ok(())
+}

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

@@ -0,0 +1,195 @@
+use crate::parser::{parse_to_graph_with_options, ParseOptions};
+use crate::{Graph, NamespaceRegistry};
+use anyhow::{Context, Result};
+use clap::{Parser, ValueEnum};
+use std::fs::read_to_string;
+use std::path::{Path, PathBuf};
+
+#[derive(Parser)]
+pub struct ValidateArgs {
+    #[arg(long, value_enum, default_value_t = OutputFormat::Human)]
+    pub format: OutputFormat,
+
+    #[arg(long)]
+    pub no_color: bool,
+
+    #[arg(long)]
+    pub show_source: bool,
+
+    #[arg(required = true)]
+    pub target: PathBuf,
+}
+
+#[derive(ValueEnum, Clone, Debug, Copy)]
+pub enum OutputFormat {
+    Json,
+    Human,
+    Lsp,
+}
+
+pub fn run(args: ValidateArgs) -> Result<()> {
+    let use_color = !args.no_color;
+
+    if args.target.is_dir() {
+        validate_directory(&args.target, args.format, use_color, args.show_source)
+    } else {
+        validate_file(&args.target, args.format, use_color, args.show_source)
+    }
+}
+
+fn validate_file(
+    path: &Path,
+    format: OutputFormat,
+    use_color: bool,
+    show_source: bool,
+) -> Result<()> {
+    let source =
+        read_to_string(path).with_context(|| format!("Failed to read file {}", path.display()))?;
+    let registry = NamespaceRegistry::discover(path).map_err(|e| anyhow::anyhow!(e.to_string()))?;
+    let default_namespace = registry
+        .as_ref()
+        .and_then(|reg| reg.namespace_for(path).map(|ns| ns.to_string()));
+    let options = ParseOptions {
+        default_namespace,
+        namespace_registry: registry.clone(),
+        entry_path: Some(path.to_path_buf()),
+        ..Default::default()
+    };
+    let graph = parse_to_graph_with_options(&source, &options)
+        .map_err(|e| anyhow::anyhow!("Parse failed for {}: {}", path.display(), e))?;
+    report_validation(graph, format, use_color, show_source, Some(&source))
+}
+
+fn validate_directory(
+    path: &Path,
+    format: OutputFormat,
+    use_color: bool,
+    show_source: bool,
+) -> Result<()> {
+    let registry = NamespaceRegistry::discover(path)
+        .map_err(|e| anyhow::anyhow!("Failed to load registry near {}: {}", path.display(), e))?
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "No .sea-registry.toml found for {}. Run inside a workspace with a registry file.",
+                path.display()
+            )
+        })?;
+
+    let files = registry
+        .resolve_files()
+        .map_err(|e| anyhow::anyhow!("Failed to expand registry: {}", e))?;
+
+    if files.is_empty() {
+        return Err(anyhow::anyhow!(
+            "Registry at '{}' did not match any .sea files",
+            registry.root().display()
+        ));
+    }
+
+    let mut graph = Graph::new();
+    for binding in files {
+        let source = read_to_string(&binding.path)
+            .with_context(|| format!("Failed to read {}", binding.path.display()))?;
+        let options = ParseOptions {
+            default_namespace: Some(binding.namespace.clone()),
+            namespace_registry: Some(registry.clone()),
+            entry_path: Some(binding.path.clone()),
+            ..Default::default()
+        };
+        let file_graph = parse_to_graph_with_options(&source, &options)
+            .map_err(|e| anyhow::anyhow!("Parse failed for {}: {}", binding.path.display(), e))?;
+        graph
+            .extend(file_graph)
+            .map_err(|e| anyhow::anyhow!("Failed to merge {}: {}", binding.path.display(), e))?;
+    }
+
+    // For directory validation, we don't pass source code for now as errors could be from any file
+    // TODO: Map errors back to specific files in directory mode
+    report_validation(graph, format, use_color, show_source, None)
+}
+
+fn report_validation(
+    graph: Graph,
+    format: OutputFormat,
+    use_color: bool,
+    show_source: bool,
+    source: Option<&str>,
+) -> Result<()> {
+    // Note: show_source and source are currently unused because validation violations
+    // don't yet include source range information. These parameters are kept for future
+    // implementation when source snippets can be displayed.
+    let _ = (show_source, source); // Acknowledge parameters for future use
+
+    let result = graph.validate();
+
+    match format {
+        OutputFormat::Json => {
+            let json_output = serde_json::json!({
+                "error_count": result.error_count,
+                "violations": result.violations.iter().map(|v| {
+                    serde_json::json!({
+                        "severity": match v.severity {
+                            crate::policy::Severity::Error => "error",
+                            crate::policy::Severity::Warning => "warning",
+                            crate::policy::Severity::Info => "info",
+                        },
+                        "policy_name": v.policy_name,
+                        "message": v.message,
+                        "context": v.context,
+                    })
+                }).collect::<Vec<_>>(),
+            });
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&json_output).context("Failed to serialize output")?
+            );
+        }
+        OutputFormat::Human | OutputFormat::Lsp => {
+            if result.error_count > 0 {
+                let msg = format!("Validation failed: {} errors", result.error_count);
+                if use_color {
+                    use colored::Colorize;
+                    println!("{}", msg.red());
+                } else {
+                    println!("{}", msg);
+                }
+
+                for v in &result.violations {
+                    let severity = match v.severity {
+                        crate::policy::Severity::Error => "ERROR",
+                        crate::policy::Severity::Warning => "WARN",
+                        crate::policy::Severity::Info => "INFO",
+                    };
+                    let severity_colored = if use_color {
+                        use colored::Colorize;
+                        match v.severity {
+                            crate::policy::Severity::Error => severity.red().to_string(),
+                            crate::policy::Severity::Warning => severity.yellow().to_string(),
+                            crate::policy::Severity::Info => severity.blue().to_string(),
+                        }
+                    } else {
+                        severity.to_string()
+                    };
+                    println!("- [{}] {}: {}", severity_colored, v.policy_name, v.message);
+                }
+            } else {
+                let msg = format!(
+                    "Validation succeeded: {} violations total",
+                    result.violations.len()
+                );
+                if use_color {
+                    use colored::Colorize;
+                    println!("{}", msg.green());
+                } else {
+                    println!("{}", msg);
+                }
+            }
+        }
+    }
+
+    if result.error_count > 0 {
+        Err(anyhow::anyhow!("Validation errors detected"))
+    } else {
+        Ok(())
+    }
+}