Cursor/dsl roadmap worker plan 965b

Cargo.toml

@@ -15,11 +15,14 @@ members = [
 
     # DSL compiler (daglang)
     "core/daglang/daglang-syntax",
+    "core/daglang/daglang-contract",
     "core/daglang/daglang-resolve",
     "core/daglang/daglang-typecheck",
     "core/daglang/daglang-lower",
     "core/daglang/daglang-derive",
     "core/daglang/daglang-emit",
+    "core/daglang/daglang-driver",
+    "core/daglang/daglang-exec-bridge",
     "core/daglang/daglang-cli",
 
     # Library crates (DAG op libraries)
@@ -55,7 +58,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"
 toml = "0.8"
-proptest = "1.4"
+proptest = "=1.4.0"
 sha2 = "0.10"
 hex = "0.4"
 glob = "0.3"

TODO/TODO_URGENT_dsl_migration.md

@@ -0,0 +1,40 @@
+# URGENT: DSL Migration Checklist
+
+Hand-rolled patterns that should migrate to daglang as the compiler matures.
+
+## Ready Now (DSL has the primitives)
+
+- [ ] **Pragma graphs** (`gunbc-dag/src/bin/pragma/graph.rs`) — 3 parallel content
+      upsert chains. Express as `pattern` invocations with service calls.
+- [ ] **Transport triplets** (all binaries) — prepare/execute/parse 3-node pattern.
+      DSL already supports via service call lowering.
+- [ ] **Codegen graph** (`gunbc-dag/src/bin/codegen/graph.rs`) — staged pipeline:
+      exists check → conditional codegen → stamp. DSL `if` in `func` bodies.
+- [ ] **Conditional execution / skip semantics** — content upsert "compare" step
+      skips write when content matches. Needs `[skip_if]` or equivalent DSL syntax.
+
+## Needs DSL Work First
+
+- [ ] **Display orchestration** (`core/exec/src/display.rs`) — channel-driven event
+      loop with timer ticks. Needs reactive/streaming DSL primitives (`observe events`,
+      `every 80ms`). Rendering IR exists (`Frame`, `FrameRenderer`, `OutputMedium`)
+      but no DSL construct generates event loops yet.
+- [ ] **Testgen dynamic targets** (`gunbc-dag/src/bin/testgen_dag/graph.rs`) — N
+      upsert chains, one per `DagSpecDef` discovered via inventory. Needs
+      compile-time metaprogramming or inventory integration in DSL.
+- [ ] **Makegen tool registry** — procedural target generation from `#[tool_target]`
+      inventory. Same metaprogramming gap as testgen.
+- [ ] **Loop extra inputs** — `for` loops where body needs non-element context
+      (e.g., `repo_path`). DSL `for` lowering doesn't model passthrough inputs yet.
+
+## DSL Maturity Snapshot (2026-02-17)
+
+| Layer | Status |
+|-------|--------|
+| Syntax (types, fn, func, pattern, service, resource, interface, pipeline) | Stable |
+| Lowering to GraphIR | Solid — patterns expand, services → triplets, resources → acq nodes |
+| Type system (records, sums, interfaces, provider resolution) | Working |
+| Pragmatic use (real tools using .dag files) | **0%** — no binary uses DSL yet |
+
+The "Ready Now" items are the highest-ROI migration targets — pragma especially,
+since it's 3 identical upsert chains that map directly to a `pattern` invocation.

core/cli/src/binary_args.rs

@@ -433,9 +433,6 @@ mod tests {
     #[test]
     fn test_step_mode_unknown_subcommand_errors() {
         let err = parse_step_mode(&argv(&["prog", "deploy"])).unwrap_err();
-        assert!(matches!(
-            err,
-            StepModeParseError::UnknownSubcommand { .. }
-        ));
+        assert!(matches!(err, StepModeParseError::UnknownSubcommand { .. }));
     }
 }

core/codegen/src/cli_gen.rs

@@ -280,7 +280,12 @@ pub fn generate_cli_with_import(
 // ============================================================================
 
 /// Build the import items for the generated CLI.
-fn build_cli_imports(tool: &ToolMeta, custom_import: Option<&str>, step_mode: bool, has_entrypoints: bool) -> Vec<Item> {
+fn build_cli_imports(
+    tool: &ToolMeta,
+    custom_import: Option<&str>,
+    step_mode: bool,
+    has_entrypoints: bool,
+) -> Vec<Item> {
     let crate_module = NamingCase::SnakeCase.apply(&tool.crate_name);
 
     // gunbc_exec imports

core/daglang/daglang-cli/Cargo.toml

@@ -10,9 +10,16 @@ daglang-syntax = { path = "../daglang-syntax" }
 daglang-resolve = { path = "../daglang-resolve" }
 daglang-typecheck = { path = "../daglang-typecheck" }
 daglang-lower = { path = "../daglang-lower" }
+daglang-contract = { path = "../daglang-contract" }
 daglang-derive = { path = "../daglang-derive" }
 daglang-emit = { path = "../daglang-emit" }
+daglang-driver = { path = "../daglang-driver" }
+daglang-exec-bridge = { path = "../daglang-exec-bridge" }
 gunbc-ir = { path = "../../ir" }
+gunbc-exec = { path = "../../exec" }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+toml = { workspace = true }
 
 [[bin]]
 name = "daglang"

core/daglang/daglang-cli/src/commands.rs

@@ -0,0 +1,253 @@
+use super::*;
+
+pub(super) fn dispatch(args: &[String], cwd: &std::path::Path) {
+    match args[1].as_str() {
+        "viz" => {
+            let (target, format) = parse_viz_args(args).unwrap_or_else(|usage| exit_usage(&usage));
+            match target {
+                VizTarget::SelfDag => {
+                    let dag = build_pipeline_dag();
+                    let rendered = match format {
+                        VizFormat::Ascii => dag.to_ascii("daglang-compiler-pipeline"),
+                        VizFormat::Mermaid => dag.to_mermaid("daglang-compiler-pipeline"),
+                    };
+                    println!("{rendered}");
+                }
+                VizTarget::CompiledTarget(path) => {
+                    let output = compile_target_or_exit(cwd, Some(&path));
+                    let rendered = match format {
+                        VizFormat::Ascii => output.lowered_dag.to_ascii("daglang-compiled"),
+                        VizFormat::Mermaid => output.lowered_dag.to_mermaid("daglang-compiled"),
+                    };
+                    println!("{rendered}");
+                }
+            }
+        }
+        "expand" => {
+            let parsed = parse_compile_command_args(
+                "expand",
+                args,
+                "expand <file.dag> [--emit-collection-nodes]",
+                true,
+            )
+            .unwrap_or_else(|usage| exit_usage(&usage));
+            let input = parsed
+                .input
+                .expect("expand parser should require input target");
+            let output = compile_target_or_exit_with_options(
+                cwd,
+                Some(&input),
+                parsed.emit_collection_nodes,
+            );
+            println!("{}", render_expand(&output.lowered_dag));
+        }
+        "manifest" => {
+            let parsed =
+                parse_manifest_command_args(args).unwrap_or_else(|usage| exit_usage(&usage));
+            let output = compile_target_or_exit_with_options(
+                cwd,
+                Some(&parsed.input),
+                parsed.emit_collection_nodes,
+            );
+            println!(
+                "{}",
+                render_manifest_with_format(&output.derived, parsed.format)
+            );
+        }
+        "obligations" => {
+            if args.len() != 3 && args.len() != 5 {
+                exit_usage("obligations <file.dag> [--format text|json]");
+            }
+            let format =
+                parse_output_format("obligations", args).unwrap_or_else(|usage| exit_usage(&usage));
+            let output = compile_target_or_exit(cwd, args.get(2));
+            println!("{}", render_obligations(&output.derived, format));
+        }
+        "show-triplets" => {
+            if args.len() != 3 && args.len() != 5 {
+                exit_usage("show-triplets <file.dag> [--format text|json]");
+            }
+            let format = parse_output_format("show-triplets", args)
+                .unwrap_or_else(|usage| exit_usage(&usage));
+            let output = compile_target_or_exit(cwd, args.get(2));
+            println!("{}", render_triplets(&output.lowered_dag, format));
+        }
+        "modules" => {
+            let (root_arg, format) =
+                parse_modules_args(args).unwrap_or_else(|usage| exit_usage(&usage));
+            if let Some(root) = &root_arg {
+                let normalized = path_utils::normalize_cli_path(cwd, &PathBuf::from(root));
+                if let Some(error) = path_utils::check_dag_extension_casing(&normalized) {
+                    eprintln!("{error}");
+                    std::process::exit(1);
+                }
+            }
+            let roots = if let Some(root) = root_arg {
+                vec![resolve_root(cwd, Some(&root))]
+            } else {
+                match resolve_configured_roots(cwd) {
+                    Ok(Some(config_roots)) => config_roots,
+                    Ok(None) => vec![resolve_root(cwd, None)],
+                    Err(error) => {
+                        eprintln!("{error}");
+                        std::process::exit(1);
+                    }
+                }
+            };
+            let context = PipelineContext {
+                roots,
+                target_file: None,
+            };
+            let result = run_pipeline_or_exit(&context, PipelineStop::Report);
+            match format {
+                OutputFormat::Text => {
+                    if let Some(report) = result.report() {
+                        println!("{report}");
+                    }
+                }
+                OutputFormat::Json => {
+                    println!("{}", render_modules_result_json(&result));
+                }
+            }
+        }
+        "check" => {
+            if args.len() > 3 {
+                exit_usage("check <file.dag|dir>");
+            }
+            if let Some(input) = args.get(2) {
+                let normalized = path_utils::normalize_cli_path(cwd, &PathBuf::from(input));
+                if let Some(error) = path_utils::check_dag_extension_casing(&normalized) {
+                    eprintln!("{error}");
+                    std::process::exit(1);
+                }
+            }
+            let configured_default_roots = if args.get(2).is_none() {
+                match resolve_configured_roots(cwd) {
+                    Ok(roots) => roots,
+                    Err(error) => {
+                        eprintln!("{error}");
+                        std::process::exit(1);
+                    }
+                }
+            } else {
+                None
+            };
+            let context = build_check_pipeline_context_with_default_roots(
+                cwd,
+                args.get(2),
+                configured_default_roots.as_deref(),
+            );
+            let result = run_pipeline_or_exit(&context, PipelineStop::Build);
+            if !result.diagnostics().is_empty() {
+                for diagnostic in result.diagnostics() {
+                    eprintln!("{diagnostic}");
+                }
+                std::process::exit(1);
+            }
+            match check_from_context(&context) {
+                Ok(output) => {
+                    println!("OK: checked {} file(s)", output.parsed_files);
+                }
+                Err(error) => {
+                    eprintln!("{error}");
+                    std::process::exit(1);
+                }
+            }
+        }
+        "compile" => {
+            let parsed = parse_compile_command_args(
+                "compile",
+                args,
+                "compile <file.dag|dir> [--emit-collection-nodes]",
+                false,
+            )
+            .unwrap_or_else(|usage| exit_usage(&usage));
+            let output = compile_target_or_exit_with_options(
+                cwd,
+                parsed.input.as_ref(),
+                parsed.emit_collection_nodes,
+            );
+            println!(
+                "Compiled {} module(s) to {} node(s), {} file(s) emitted.",
+                output.emitted.summary.module_count,
+                output.derived.manifest.total_nodes,
+                output.emitted.files.len()
+            );
+            for file in &output.emitted.files {
+                println!("  - {}", file.path);
+            }
+        }
+        "run" => {
+            let parsed = parse_run_args(args).unwrap_or_else(|error| {
+                eprintln!("{error}");
+                exit_usage(
+                    "run [--output <path>|--output=<path>] [--dry-run|--check-mode] <file.dag>",
+                );
+            });
+            let normalized_output_path =
+                path_utils::normalize_cli_path(cwd, &PathBuf::from(&parsed.output_path));
+            let output_path_str = normalized_output_path.to_string_lossy().to_string();
+            let input_mocks = makegen_entrypoint_mocks(&output_path_str);
+            let mode = match parsed.mode {
+                RunMode::Real => ExecutionMode::Real,
+                RunMode::DryRun => {
+                    ExecutionMode::DryRun(makegen_dry_run_transport_mocks(&output_path_str))
+                }
+                RunMode::CheckMode => {
+                    ExecutionMode::DryRun(makegen_check_mode_transport_mocks(&output_path_str))
+                }
+            };
+            let context = build_context(cwd, Some(&parsed.input_path));
+            let output = match compile_from_context(&context) {
+                Ok(output) => output,
+                Err(error) => {
+                    eprintln!("{error}");
+                    std::process::exit(1);
+                }
+            };
+            let resolved = match resolve_lowered_dag(&output.lowered_dag) {
+                Ok(resolved) => resolved,
+                Err(error) => {
+                    eprintln!("resolve error: {error}");
+                    std::process::exit(1);
+                }
+            };
+            let log = match execute_resolved_dag(&resolved, mode, Some(&input_mocks)) {
+                Ok(log) => log,
+                Err(error) => {
+                    eprintln!("execution error: {error}");
+                    std::process::exit(1);
+                }
+            };
+            let written = log
+                .get("tools.makegen::makegen")
+                .and_then(|entry| entry.outputs.get("written"))
+                .and_then(Value::as_bool)
+                .unwrap_or(false);
+            let fresh = log
+                .get("compare_makegen_content")
+                .and_then(|entry| entry.outputs.get("fresh"))
+                .and_then(Value::as_bool);
+            let mode_label = match parsed.mode {
+                RunMode::Real => "real",
+                RunMode::DryRun => "dry-run",
+                RunMode::CheckMode => "check-mode",
+            };
+            if parsed.mode == RunMode::CheckMode && fresh == Some(false) {
+                eprintln!(
+                    "check-mode failed: output is stale at {}",
+                    normalized_output_path.display()
+                );
+                std::process::exit(2);
+            }
+            println!(
+                "OK: run mode={mode_label} output={} written={written}",
+                normalized_output_path.display()
+            );
+        }
+        cmd => {
+            eprintln!("Unknown command: {cmd}");
+            exit_usage("<command> [args...]");
+        }
+    }
+}