restore TS example pipelines + prefer-TS dual-language detection

Author: markovejnovic

crates/hm-dsl-engine/src/detect.rs

@@ -5,39 +5,53 @@ use anyhow::{Context, bail};
 use crate::DslLanguage;
 
 /// Detect the DSL language used in a project by scanning `.hm/` for file
-/// extensions.
-///
-/// A repo carrying **both** a `.py` and a `.ts` pipeline is rejected rather
-/// than silently tie-broken: `hm run` (local) and the backend discovery path
-/// (`hm pipelines` / `hm render`) both route through this one resolver, so a
-/// tie-break here would let the local build run one language while cloud
-/// discovery built the other. Failing fast keeps the two in lockstep. Keep a
-/// single pipeline language per `.hm/` directory.
+/// extensions. Prefers **TypeScript** when both are present (the `hm run`
+/// default).
 ///
 /// # Errors
 ///
 /// - The `.hm/` directory does not exist.
 /// - No `.py` or `.ts` files are found inside `.hm/`.
-/// - Both `.py` and `.ts` files are present (ambiguous language).
 pub fn detect_language(repo_root: &Path) -> anyhow::Result<DslLanguage> {
     let harmont_dir = repo_root.join(".hm");
     if !harmont_dir.is_dir() {
         bail!("no .hm/ directory found in {}", repo_root.display());
     }
     let langs = scan_extensions(repo_root)?;
-    match (langs.has_py, langs.has_ts) {
-        (true, true) => bail!(
-            "ambiguous pipeline language in {dir}: found both Python (.py) and \
-             TypeScript (.ts) pipeline files\n  \
-             → keep exactly one pipeline language per .hm/ directory; remove the \
-             extra .py or .ts files\n  \
-             (otherwise `hm run` and cloud discovery could resolve different \
-             languages for the same repo)",
-            dir = harmont_dir.display()
-        ),
-        (false, true) => Ok(DslLanguage::TypeScript),
-        (true, false) => Ok(DslLanguage::Python),
-        (false, false) => bail!("no .py or .ts files found in {}", harmont_dir.display()),
+    if langs.has_ts {
+        // When both languages are present, prefer TypeScript.
+        Ok(DslLanguage::TypeScript)
+    } else if langs.has_py {
+        Ok(DslLanguage::Python)
+    } else {
+        bail!("no .py or .ts files found in {}", harmont_dir.display())
+    }
+}
+
+/// Like [`detect_language`] but prefers **Python** when both are present.
+///
+/// Used by the machine-facing `hm pipelines` / `hm render` commands that the
+/// backend shells out to: the Python path is the fully-supported one (the
+/// discovery envelope is Python-only today), so a repo carrying both a `.py`
+/// and a redundant `.ts` resolves to Python rather than the unsupported TS
+/// registry. `hm run` keeps the TypeScript-preferring [`detect_language`].
+///
+/// # Errors
+///
+/// - The `.hm/` directory does not exist.
+/// - No `.py` or `.ts` files are found inside `.hm/`.
+pub fn detect_language_python_first(repo_root: &Path) -> anyhow::Result<DslLanguage> {
+    let harmont_dir = repo_root.join(".hm");
+    if !harmont_dir.is_dir() {
+        bail!("no .hm/ directory found in {}", repo_root.display());
+    }
+    let langs = scan_extensions(repo_root)?;
+    if langs.has_py {
+        Ok(DslLanguage::Python)
+    } else if langs.has_ts {
+        Ok(DslLanguage::TypeScript)
+    } else {
+        bail!("no .py or .ts files found in {}", harmont_dir.display())
     }
 }
 
@@ -46,7 +60,7 @@ pub fn detect_language(repo_root: &Path) -> anyhow::Result<DslLanguage> {
 /// The backend fans pipeline discovery out across every repo in an
 /// installation, most of which declare no pipelines at all. Those repos should
 /// yield an empty registry, not an error — callers use this to short-circuit to
-/// an empty envelope instead of calling [`detect_language`].
+/// an empty envelope instead of calling [`detect_language_python_first`].
 #[must_use]
 pub fn has_pipeline_files(repo_root: &Path) -> bool {
     matches!(scan_extensions(repo_root), Ok(langs) if langs.has_py || langs.has_ts)
@@ -120,18 +134,10 @@ mod tests {
     }
 
     #[test]
-    fn mixed_languages_is_ambiguous_error() {
-        // A repo declaring both .py and .ts must fail loudly rather than
-        // silently tie-break — otherwise local `hm run` and cloud discovery
-        // could resolve different languages for the same repo.
+    fn mixed_languages_prefers_typescript() {
         let tmp = setup(&["ci.py", "deploy.ts"]);
-        let err = detect_language(tmp.path()).unwrap_err();
-        let msg = err.to_string();
-        assert!(
-            msg.contains("ambiguous pipeline language"),
-            "unexpected error: {msg}"
-        );
-        assert!(msg.contains(".py") && msg.contains(".ts"), "msg: {msg}");
+        let lang = detect_language(tmp.path()).unwrap();
+        assert_eq!(lang, DslLanguage::TypeScript);
     }
 
     #[test]
@@ -155,6 +161,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn python_first_prefers_python_when_mixed() {
+        let tmp = setup(&["ci.py", "deploy.ts"]);
+        assert_eq!(
+            detect_language_python_first(tmp.path()).unwrap(),
+            DslLanguage::Python
+        );
+    }
+
+    #[test]
+    fn python_first_falls_back_to_typescript_when_only_ts() {
+        let tmp = setup(&["ci.ts"]);
+        assert_eq!(
+            detect_language_python_first(tmp.path()).unwrap(),
+            DslLanguage::TypeScript
+        );
+    }
+
+    #[test]
+    fn python_first_no_harmont_dir_is_error() {
+        let tmp = TempDir::new().unwrap();
+        let err = detect_language_python_first(tmp.path()).unwrap_err();
+        assert!(
+            err.to_string().contains("no .hm/ directory"),
+            "unexpected error: {err}"
+        );
+    }
+
     #[test]
     fn has_pipeline_files_true_for_py_and_ts() {
         assert!(has_pipeline_files(setup(&["ci.py"]).path()));

crates/hm/src/cli/pipelines.rs

@@ -22,9 +22,9 @@ const EMPTY_ENVELOPE: &str = r#"{"schema_version":"1","pipelines":[]}"#;
 /// declares no pipelines and yields the empty envelope rather than an error —
 /// the backend fans discovery out across every repo in an installation, most of
 /// which carry no pipelines. Both Python and TypeScript pipelines emit the same
-/// discovery envelope; a repo declaring both languages is rejected by
-/// [`detect::detect_language`] so local `hm run` and cloud discovery can never
-/// resolve different languages.
+/// discovery envelope; a repo declaring both languages resolves to Python via
+/// [`detect::detect_language_python_first`] (the fully-supported backend path),
+/// matching `hm render`.
 ///
 /// # Errors
 ///
@@ -41,7 +41,8 @@ pub async fn run(args: PipelinesArgs) -> Result<()> {
         return Ok(());
     }
 
-    let lang = detect::detect_language(&repo_root).context("detecting pipeline language")?;
+    let lang =
+        detect::detect_language_python_first(&repo_root).context("detecting pipeline language")?;
     let engine = engine_for(lang).context("initializing DSL engine")?;
     let json = engine
         .registry_json(&repo_root)

crates/hm/src/cli/render.rs

@@ -31,7 +31,8 @@ pub async fn run(args: RenderArgs) -> Result<()> {
         None => std::env::current_dir().context("cannot determine current directory")?,
     };
 
-    let lang = detect::detect_language(&repo_root).context("detecting pipeline language")?;
+    let lang =
+        detect::detect_language_python_first(&repo_root).context("detecting pipeline language")?;
     let engine = engine_for(lang).context("initializing DSL engine")?;
     let json = engine
         .render_pipeline_json(&repo_root, &args.slug)

examples/bun/.hm/pipeline.ts

@@ -0,0 +1,17 @@
+import { pipeline, push, type PipelineDefinition } from "@harmont/hm";
+import { js } from "@harmont/hm/toolchains";
+
+const project = js.project({ runtime: "bun" });
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" })],
+    pipeline: pipeline([project.run("build"), project.run("test"), project.run("lint")], {
+      env: { CI: "true" },
+      defaultImage: "ubuntu:24.04",
+    }),
+  },
+];
+
+export default pipelines;

examples/c/.hm/pipeline.ts

@@ -0,0 +1,17 @@
+import { pipeline, push, type PipelineDefinition } from "@harmont/hm";
+import { cmake } from "@harmont/hm/toolchains";
+
+const project = cmake({ path: ".", defines: { CMAKE_BUILD_TYPE: "Release" } });
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" })],
+    pipeline: pipeline([project.test(), project.fmt()], {
+      env: { CI: "true" },
+      defaultImage: "ubuntu:24.04",
+    }),
+  },
+];
+
+export default pipelines;

examples/cmake-advanced/.hm/pipeline.ts

@@ -0,0 +1,25 @@
+import { pipeline, push, pullRequest, type PipelineDefinition } from "@harmont/hm";
+import { cmake } from "@harmont/hm/toolchains";
+
+const project = cmake({
+  path: ".",
+  compiler: "clang-18",
+  defines: {
+    CMAKE_BUILD_TYPE: "Release",
+    CMAKE_CXX_STANDARD: "20",
+    BUILD_TESTING: "ON",
+  },
+});
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" }), pullRequest()],
+    pipeline: pipeline([project.test(), project.lint(), project.fmt()], {
+      env: { CI: "true" },
+      defaultImage: "ubuntu:24.04",
+    }),
+  },
+];
+
+export default pipelines;

examples/cpp/.hm/pipeline.ts

@@ -0,0 +1,17 @@
+import { pipeline, push, type PipelineDefinition } from "@harmont/hm";
+import { cmake } from "@harmont/hm/toolchains";
+
+const project = cmake({ path: ".", defines: { CMAKE_BUILD_TYPE: "Release", CMAKE_CXX_STANDARD: "17" } });
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" })],
+    pipeline: pipeline([project.test(), project.lint(), project.fmt()], {
+      env: { CI: "true" },
+      defaultImage: "ubuntu:24.04",
+    }),
+  },
+];
+
+export default pipelines;

examples/elixir-phoenix/.hm/pipeline.ts

@@ -0,0 +1,44 @@
+import { pipeline, push, pullRequest, type PipelineDefinition } from "@harmont/hm";
+import { elixir } from "@harmont/hm/toolchains";
+
+const project = elixir({
+  path: ".",
+  elixirVersion: "1.18.3",
+  otpVersion: "27.3.3",
+});
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" }), pullRequest()],
+    pipeline: pipeline(
+      [
+        project.compile(),
+        project.test({ cover: true }),
+        project.format(),
+        project.credo(),
+        project.dialyzer(),
+        project.sobelow(),
+        project.depsAudit(),
+        project.hexAudit(),
+      ],
+      {
+        env: {
+          CI: "true",
+          MIX_ENV: "test",
+        },
+        defaultImage: "ubuntu:24.04",
+      },
+    ),
+  },
+  {
+    slug: "deploy",
+    triggers: [push({ branch: "main" })],
+    pipeline: pipeline(
+      [project.compile(), project.mix("assets.deploy"), project.release()],
+      { env: { MIX_ENV: "prod" }, defaultImage: "ubuntu:24.04" },
+    ),
+  },
+];
+
+export default pipelines;

examples/elixir/.hm/pipeline.ts

@@ -0,0 +1,25 @@
+import { pipeline, push, type PipelineDefinition } from "@harmont/hm";
+import { elixir } from "@harmont/hm/toolchains";
+
+const project = elixir({ path: "." });
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" })],
+    pipeline: pipeline(
+      [
+        project.compile(),
+        project.test(),
+        project.format(),
+        project.credo(),
+        project.dialyzer(),
+        project.depsAudit(),
+        project.hexAudit(),
+      ],
+      { env: { CI: "true", MIX_ENV: "test" }, defaultImage: "ubuntu:24.04" },
+    ),
+  },
+];
+
+export default pipelines;

examples/go/.hm/pipeline.ts

@@ -0,0 +1,17 @@
+import { pipeline, push, type PipelineDefinition } from "@harmont/hm";
+import { go } from "@harmont/hm/toolchains";
+
+const project = go({ path: "." });
+
+const pipelines: PipelineDefinition[] = [
+  {
+    slug: "ci",
+    triggers: [push({ branch: "main" })],
+    pipeline: pipeline(
+      [project.build(), project.test(), project.vet(), project.fmt()],
+      { env: { CI: "true" }, defaultImage: "ubuntu:24.04" },
+    ),
+  },
+];
+
+export default pipelines;