bootstrap an MCP through Rewatch, with an initial 'diagnose' command

Author: zth

rewatch/Cargo.lock

@@ -26,6 +26,9 @@ serde = { version = "1.0.152", features = ["derive"] }
 serde_json = { version = "1.0.93" }
 sysinfo = "0.29.10"
 tempfile = "3.10.1"
+mcp-server = "0.1.0"
+mcp-spec = "0.1.0"
+tokio = { version = "1", features = ["rt-multi-thread", "io-std"] }
 
 
 [profile.release]

rewatch/Cargo.toml

@@ -436,39 +436,17 @@ pub fn compiler_args(
     // Command-line --warn-error flag override (takes precedence over rescript.json config)
     warn_error_override: Option<String>,
 ) -> Result<Vec<String>> {
-    let bsc_flags = config::flatten_flags(&config.compiler_flags);
-    let dependency_paths = get_dependency_paths(config, project_context, packages, is_type_dev);
     let module_name = helpers::file_path_to_module_name(file_path, &config.get_namespace());
-
-    let namespace_args = match &config.get_namespace() {
-        packages::Namespace::NamespaceWithEntry { namespace: _, entry } if &module_name == entry => {
-            // if the module is the entry we just want to open the namespace
-            vec![
-                "-open".to_string(),
-                config.get_namespace().to_suffix().unwrap().to_string(),
-            ]
-        }
-        packages::Namespace::Namespace(_)
-        | packages::Namespace::NamespaceWithEntry {
-            namespace: _,
-            entry: _,
-        } => {
-            vec![
-                "-bs-ns".to_string(),
-                config.get_namespace().to_suffix().unwrap().to_string(),
-            ]
-        }
-        packages::Namespace::NoNamespace => vec![],
-    };
-
-    let root_config = project_context.get_root_config();
-    let jsx_args = root_config.get_jsx_args();
-    let jsx_module_args = root_config.get_jsx_module_args();
-    let jsx_mode_args = root_config.get_jsx_mode_args();
-    let jsx_preserve_args = root_config.get_jsx_preserve_args();
-    let gentype_arg = config.get_gentype_arg();
-    let experimental_args = root_config.get_experimental_features_args();
-    let warning_args = config.get_warning_args(is_local_dep, warn_error_override);
+    let base_args = base_compile_args(
+        config,
+        file_path,
+        project_context,
+        packages,
+        is_type_dev,
+        is_local_dep,
+        warn_error_override,
+        None,
+    )?;
 
     let read_cmi_args = match has_interface {
         true => {
@@ -483,6 +461,7 @@ pub fn compiler_args(
 
     let package_name_arg = vec!["-bs-package-name".to_string(), config.name.to_owned()];
 
+    let root_config = project_context.get_root_config();
     let implementation_args = if is_interface {
         debug!("Compiling interface file: {}", &module_name);
         vec![]
@@ -517,11 +496,116 @@ pub fn compiler_args(
             .collect()
     };
 
+    Ok(vec![
+        base_args,
+        read_cmi_args,
+        // vec!["-warn-error".to_string(), "A".to_string()],
+        // ^^ this one fails for bisect-ppx
+        // this is the default
+        // we should probably parse the right ones from the package config
+        // vec!["-w".to_string(), "a".to_string()],
+        package_name_arg,
+        implementation_args,
+        vec![ast_path.to_string_lossy().to_string()],
+    ]
+    .concat())
+}
+
+pub fn compiler_args_for_diagnostics(
+    config: &config::Config,
+    file_path: &Path,
+    is_interface: bool,
+    has_interface: bool,
+    project_context: &ProjectContext,
+    packages: &Option<&AHashMap<String, packages::Package>>,
+    is_type_dev: bool,
+    is_local_dep: bool,
+    warn_error_override: Option<String>,
+    ppx_flags: Vec<String>,
+) -> Result<Vec<String>> {
+    let mut args = base_compile_args(
+        config,
+        file_path,
+        project_context,
+        packages,
+        is_type_dev,
+        is_local_dep,
+        warn_error_override,
+        Some(ppx_flags),
+    )?;
+
+    // Gate -bs-read-cmi by .cmi presence to avoid noisy errors when a project hasn't been built yet.
+    if has_interface && !is_interface {
+        let pkg_root = config
+            .path
+            .parent()
+            .map(|p| p.to_path_buf())
+            .unwrap_or_else(|| Path::new(".").to_path_buf());
+        let ocaml_build_path = packages::get_ocaml_build_path(&pkg_root);
+        let basename = helpers::file_path_to_compiler_asset_basename(file_path, &config.get_namespace());
+        let cmi_exists = ocaml_build_path.join(format!("{basename}.cmi")).exists();
+        if cmi_exists {
+            args.push("-bs-read-cmi".to_string());
+        }
+    }
+
+    args.extend([
+        "-color".to_string(),
+        "never".to_string(),
+        "-ignore-parse-errors".to_string(),
+        "-editor-mode".to_string(),
+    ]);
+
+    args.push(file_path.to_string_lossy().to_string());
+    Ok(args)
+}
+
+fn base_compile_args(
+    config: &config::Config,
+    file_path: &Path,
+    project_context: &ProjectContext,
+    packages: &Option<&AHashMap<String, packages::Package>>,
+    is_type_dev: bool,
+    is_local_dep: bool,
+    warn_error_override: Option<String>,
+    include_ppx_flags: Option<Vec<String>>,
+) -> Result<Vec<String>> {
+    let bsc_flags = config::flatten_flags(&config.compiler_flags);
+    let dependency_paths = get_dependency_paths(config, project_context, packages, is_type_dev);
+    let module_name = helpers::file_path_to_module_name(file_path, &config.get_namespace());
+
+    let namespace_args = match &config.get_namespace() {
+        packages::Namespace::NamespaceWithEntry { namespace: _, entry } if &module_name == entry => {
+            vec![
+                "-open".to_string(),
+                config.get_namespace().to_suffix().unwrap().to_string(),
+            ]
+        }
+        packages::Namespace::Namespace(_)
+        | packages::Namespace::NamespaceWithEntry {
+            namespace: _,
+            entry: _,
+        } => {
+            vec![
+                "-bs-ns".to_string(),
+                config.get_namespace().to_suffix().unwrap().to_string(),
+            ]
+        }
+        packages::Namespace::NoNamespace => vec![],
+    };
+
+    let root_config = project_context.get_root_config();
+    let jsx_args = root_config.get_jsx_args();
+    let jsx_module_args = root_config.get_jsx_module_args();
+    let jsx_mode_args = root_config.get_jsx_mode_args();
+    let jsx_preserve_args = root_config.get_jsx_preserve_args();
+    let gentype_arg = config.get_gentype_arg();
+    let experimental_args = root_config.get_experimental_features_args();
+    let warning_args = config.get_warning_args(is_local_dep, warn_error_override);
     let runtime_path_args = get_runtime_path_args(config, project_context)?;
 
     Ok(vec![
         namespace_args,
-        read_cmi_args,
         vec![
             "-I".to_string(),
             Path::new("..").join("ocaml").to_string_lossy().to_string(),
@@ -532,22 +616,11 @@ pub fn compiler_args(
         jsx_module_args,
         jsx_mode_args,
         jsx_preserve_args,
+        include_ppx_flags.unwrap_or_default(),
         bsc_flags.to_owned(),
         warning_args,
         gentype_arg,
         experimental_args,
-        // vec!["-warn-error".to_string(), "A".to_string()],
-        // ^^ this one fails for bisect-ppx
-        // this is the default
-        // we should probably parse the right ones from the package config
-        // vec!["-w".to_string(), "a".to_string()],
-        package_name_arg,
-        implementation_args,
-        // vec![
-        //     "-I".to_string(),
-        //     abs_node_modules_path.to_string() + "/rescript/ocaml",
-        // ],
-        vec![ast_path.to_string_lossy().to_string()],
     ]
     .concat())
 }

rewatch/src/build/compile.rs

@@ -284,11 +284,7 @@ pub fn parser_args(
     let root_config = project_context.get_root_config();
     let file = &filename;
     let ast_path = helpers::get_ast_path(file);
-    let ppx_flags = config::flatten_ppx_flags(
-        project_context,
-        package_config,
-        &filter_ppx_flags(&package_config.ppx_flags, contents),
-    )?;
+    let ppx_flags = ppx_flags_for_contents(project_context, package_config, contents)?;
     let jsx_args = root_config.get_jsx_args();
     let jsx_module_args = root_config.get_jsx_module_args();
     let jsx_mode_args = root_config.get_jsx_mode_args();
@@ -322,6 +318,15 @@ pub fn parser_args(
     ))
 }
 
+pub fn ppx_flags_for_contents(
+    project_context: &ProjectContext,
+    package_config: &Config,
+    contents: &str,
+) -> anyhow::Result<Vec<String>> {
+    let filtered = filter_ppx_flags(&package_config.ppx_flags, contents);
+    config::flatten_ppx_flags(project_context, package_config, &filtered)
+}
+
 fn generate_ast(
     package: Package,
     filename: &Path,

rewatch/src/build/parse.rs

@@ -425,6 +425,8 @@ pub enum Command {
     Build(BuildArgs),
     /// Build, then start a watcher
     Watch(WatchArgs),
+    /// Start a Model Context Protocol (MCP) server over stdio
+    Mcp {},
     /// Clean the build artifacts
     Clean {
         #[command(flatten)]

rewatch/src/cli.rs

@@ -5,6 +5,7 @@ pub mod config;
 pub mod format;
 pub mod helpers;
 pub mod lock;
+pub mod mcp;
 pub mod project_context;
 pub mod queue;
 pub mod sourcedirs;

rewatch/src/lib.rs

@@ -3,17 +3,23 @@ use console::Term;
 use log::LevelFilter;
 use std::{io::Write, path::Path};
 
-use rescript::{build, cli, cmd, format, lock, watcher};
+use rescript::{build, cli, cmd, format, lock, mcp, watcher};
 
 fn main() -> Result<()> {
     let cli = cli::parse_with_default().unwrap_or_else(|err| err.exit());
 
     let log_level_filter = cli.verbose.log_level_filter();
 
+    // Route logs to stderr when running the MCP server to keep stdout as a pure JSON-RPC stream.
+    let logs_to_stdout = !matches!(cli.command, cli::Command::Mcp { .. });
     env_logger::Builder::new()
         .format(|buf, record| writeln!(buf, "{}:\n{}", record.level(), record.args()))
         .filter_level(log_level_filter)
-        .target(env_logger::fmt::Target::Stdout)
+        .target(if logs_to_stdout {
+            env_logger::fmt::Target::Stdout
+        } else {
+            env_logger::fmt::Target::Stderr
+        })
         .init();
 
     let mut command = cli.command;
@@ -37,6 +43,13 @@ fn main() -> Result<()> {
             println!("{}", build::get_compiler_args(Path::new(&path))?);
             std::process::exit(0);
         }
+        cli::Command::Mcp {} => {
+            if let Err(e) = mcp::run() {
+                println!("{e}");
+                std::process::exit(1);
+            }
+            std::process::exit(0);
+        }
         cli::Command::Build(build_args) => {
             let _lock = get_lock(&build_args.folder);