[WIP] Adding Giter8 support

modules/core/src/main/scala/org/scalasteward/core/application/Context.scala

@@ -25,6 +25,8 @@ import org.http4s.client.Client
 import org.http4s.headers.`User-Agent`
 import org.scalasteward.core.application.Config.ForgeCfg
 import org.scalasteward.core.buildtool.BuildToolDispatcher
+import org.scalasteward.core.buildtool.BuildToolCandidates
+import org.scalasteward.core.buildtool.giter8.Giter8Alg
 import org.scalasteward.core.buildtool.gradle.GradleAlg
 import org.scalasteward.core.buildtool.maven.MavenAlg
 import org.scalasteward.core.buildtool.mill.MillAlg
@@ -62,6 +64,7 @@ final class Context[F[_]](implicit
     val filterAlg: FilterAlg[F],
     val forgeRepoAlg: ForgeRepoAlg[F],
     val gitAlg: GitAlg[F],
+    val giter8Alg: Giter8Alg[F],
     val gradleAlg: GradleAlg[F],
     val hookExecutor: HookExecutor[F],
     val httpJsonClient: HttpJsonClient[F],
@@ -184,6 +187,8 @@ object Context {
         new SbtAlg[F](config.defaultResolvers, config.ignoreOptsFiles)
       implicit val scalaCliAlg: ScalaCliAlg[F] = new ScalaCliAlg[F]
       implicit val millAlg: MillAlg[F] = new MillAlg[F](config.defaultResolvers)
+      implicit val buildToolCandidates: BuildToolCandidates[F] = BuildToolCandidates.create[F]
+      implicit val giter8Alg: Giter8Alg[F] = Giter8Alg.create[F]
       implicit val buildToolDispatcher: BuildToolDispatcher[F] = new BuildToolDispatcher[F]
       implicit val refreshErrorAlg: RefreshErrorAlg[F] =
         new RefreshErrorAlg[F](refreshErrorStore, config.refreshBackoffPeriod)

modules/core/src/main/scala/org/scalasteward/core/buildtool/BuildToolCandidates.scala

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2018-2025 Scala Steward contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.scalasteward.core.buildtool
+
+import cats.Monad
+import cats.syntax.all.*
+import org.scalasteward.core.buildtool.gradle.GradleAlg
+import org.scalasteward.core.buildtool.maven.MavenAlg
+import org.scalasteward.core.buildtool.mill.MillAlg
+import org.scalasteward.core.buildtool.sbt.SbtAlg
+import org.scalasteward.core.buildtool.scalacli.ScalaCliAlg
+
+final class BuildToolCandidates[F[_]](implicit
+    gradleAlg: GradleAlg[F],
+    mavenAlg: MavenAlg[F],
+    millAlg: MillAlg[F],
+    sbtAlg: SbtAlg[F],
+    scalaCliAlg: ScalaCliAlg[F],
+    F: Monad[F]
+) {
+  val all: List[BuildToolAlg[F]] = List(gradleAlg, mavenAlg, millAlg, sbtAlg, scalaCliAlg)
+
+  val fallback: List[BuildToolAlg[F]] = List(sbtAlg)
+
+  def findBuildTools(buildRoot: BuildRoot): F[(BuildRoot, List[BuildToolAlg[F]])] =
+    all.filterA(_.containsBuild(buildRoot)).map {
+      case Nil  => buildRoot -> fallback
+      case list => buildRoot -> list
+    }
+}
+
+object BuildToolCandidates {
+  def create[F[_]](implicit
+      gradleAlg: GradleAlg[F],
+      mavenAlg: MavenAlg[F],
+      millAlg: MillAlg[F],
+      sbtAlg: SbtAlg[F],
+      scalaCliAlg: ScalaCliAlg[F],
+      F: Monad[F]
+  ): BuildToolCandidates[F] = new BuildToolCandidates
+}

modules/core/src/main/scala/org/scalasteward/core/buildtool/BuildToolDispatcher.scala

@@ -18,24 +18,17 @@ package org.scalasteward.core.buildtool
 
 import cats.Monad
 import cats.syntax.all.*
-import org.scalasteward.core.buildtool.gradle.GradleAlg
-import org.scalasteward.core.buildtool.maven.MavenAlg
-import org.scalasteward.core.buildtool.mill.MillAlg
-import org.scalasteward.core.buildtool.sbt.SbtAlg
-import org.scalasteward.core.buildtool.scalacli.ScalaCliAlg
+import org.scalasteward.core.buildtool.giter8.Giter8Alg
 import org.scalasteward.core.data.{Repo, Scope}
 import org.scalasteward.core.edit.scalafix.ScalafixMigration
 import org.scalasteward.core.repoconfig.RepoConfig
 import org.scalasteward.core.scalafmt.ScalafmtAlg
 import org.typelevel.log4cats.Logger
 
 final class BuildToolDispatcher[F[_]](implicit
-    gradleAlg: GradleAlg[F],
+    buildToolCandidates: BuildToolCandidates[F],
+    giter8Alg: Giter8Alg[F],
     logger: Logger[F],
-    mavenAlg: MavenAlg[F],
-    millAlg: MillAlg[F],
-    sbtAlg: SbtAlg[F],
-    scalaCliAlg: ScalaCliAlg[F],
     scalafmtAlg: ScalafmtAlg[F],
     F: Monad[F]
 ) {
@@ -55,18 +48,14 @@ final class BuildToolDispatcher[F[_]](implicit
       buildTools.traverse_(_.runMigration(buildRoot, migration))
     })
 
-  private val allBuildTools = List(gradleAlg, mavenAlg, millAlg, sbtAlg, scalaCliAlg)
-  private val fallbackBuildTool = List(sbtAlg)
-
-  private def findBuildTools(buildRoot: BuildRoot): F[(BuildRoot, List[BuildToolAlg[F]])] =
-    allBuildTools.filterA(_.containsBuild(buildRoot)).map {
-      case Nil  => buildRoot -> fallbackBuildTool
-      case list => buildRoot -> list
-    }
-
   private def getBuildRootsAndTools(
       repo: Repo,
       repoConfig: RepoConfig
   ): F[List[(BuildRoot, List[BuildToolAlg[F]])]] =
-    repoConfig.buildRootsOrDefault(repo).traverse(findBuildTools)
+    for {
+      baseBuildRoots <- repoConfig.buildRootsOrDefault(repo).pure[F]
+      giter8BuildRoot <- giter8Alg.getGiter8BuildRoot(repo)
+      allBuildRoots = giter8BuildRoot.fold(baseBuildRoots)(g8 => baseBuildRoots :+ g8)
+      result <- allBuildRoots.traverse(buildToolCandidates.findBuildTools)
+    } yield result
 }

modules/core/src/main/scala/org/scalasteward/core/buildtool/giter8/Giter8Alg.scala

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018-2025 Scala Steward contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.scalasteward.core.buildtool.giter8
+
+import cats.Monad
+import cats.data.OptionT
+import cats.syntax.all.*
+import org.scalasteward.core.buildtool.BuildRoot
+import org.scalasteward.core.data.Repo
+import org.scalasteward.core.io.WorkspaceAlg
+
+final class Giter8Alg[F[_]](implicit
+                            workspaceAlg: WorkspaceAlg[F],
+                            F: Monad[F]
+                           ) {
+  private val giter8TemplateDir = "src/main/g8"
+
+  def getGiter8BuildRoot(repo: Repo): F[Option[BuildRoot]] = {
+    val g8BuildRoot = BuildRoot(repo, giter8TemplateDir)
+    // Not the prettiest version of this, but I'm not sure how to deal
+    // with the Option.when(F[_])(A), closest is OptionT.whenM( but that requires an F[A].
+    OptionT(isGiter8Template(repo).map(Option.when(_)(g8BuildRoot)))
+      .value
+  }
+
+  private def isGiter8Template(repo: Repo): F[Boolean] =
+    workspaceAlg.repoDir(repo).map { repoDir =>
+      repo.repo.endsWith(".g8") || (repoDir / giter8TemplateDir).isDirectory
+    }
+}
+
+object Giter8Alg {
+  def create[F[_]](implicit
+                   workspaceAlg: WorkspaceAlg[F],
+                   F: Monad[F]
+                  ): Giter8Alg[F] = new Giter8Alg
+}

modules/core/src/test/scala/org/scalasteward/core/buildtool/BuildToolDispatcherTest.scala

@@ -106,4 +106,60 @@ class BuildToolDispatcherTest extends FunSuite {
     )
     assertEquals(deps, expectedDeps)
   }
+
+  test("getDependencies: repo name ends with .g8 includes giter8 build root") {
+    val repo = Repo("example", "kafka-streams.g8")
+    val repoConfig = RepoConfig.empty
+    val repoDir = workspaceAlg.repoDir(repo).unsafeRunSync()
+    val initial = MockState.empty
+      .addFiles(
+        repoDir / "build.sbt" -> "lazy val root = ...",
+        repoDir / "project" / "build.properties" -> "sbt.version=1.2.6",
+        repoDir / scalafmtConfName -> "version=2.0.0",
+        repoDir / "src" / "main" / "g8" / "build.sbt" -> "lazy val root = ..."
+      )
+      .unsafeRunSync()
+    val (state, deps) =
+      buildToolDispatcher.getDependencies(repo, repoConfig).runSA(initial).unsafeRunSync()
+
+    // Should have dependencies from both the main build and the giter8 template
+    assert(deps.length >= 1)
+  }
+
+  test("getDependencies: src/main/g8 directory exists includes giter8 build root") {
+    val repo = Repo("example", "my-project")
+    val repoConfig = RepoConfig.empty
+    val repoDir = workspaceAlg.repoDir(repo).unsafeRunSync()
+    val initial = MockState.empty
+      .addFiles(
+        repoDir / "build.sbt" -> "lazy val root = ...",
+        repoDir / "project" / "build.properties" -> "sbt.version=1.2.6",
+        repoDir / scalafmtConfName -> "version=2.0.0",
+        repoDir / "src" / "main" / "g8" / "build.sbt" -> "lazy val root = ..."
+      )
+      .unsafeRunSync()
+    val (state, deps) =
+      buildToolDispatcher.getDependencies(repo, repoConfig).runSA(initial).unsafeRunSync()
+
+    // Should have dependencies from both the main build and the giter8 template
+    assert(deps.length >= 1)
+  }
+
+  test("getDependencies: no giter8 template returns only base build roots") {
+    val repo = Repo("example", "regular-project")
+    val repoConfig = RepoConfig.empty
+    val repoDir = workspaceAlg.repoDir(repo).unsafeRunSync()
+    val initial = MockState.empty
+      .addFiles(
+        repoDir / "build.sbt" -> "lazy val root = ...",
+        repoDir / "project" / "build.properties" -> "sbt.version=1.2.6",
+        repoDir / scalafmtConfName -> "version=2.0.0"
+      )
+      .unsafeRunSync()
+    val (state, deps) =
+      buildToolDispatcher.getDependencies(repo, repoConfig).runSA(initial).unsafeRunSync()
+
+    // Should have only one set of dependencies from the main build
+    assertEquals(deps.length, 1)
+  }
 }

modules/core/src/test/scala/org/scalasteward/core/buildtool/giter8/Giter8AlgTest.scala

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2018-2025 Scala Steward contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.scalasteward.core.buildtool.giter8
+
+import cats.effect.unsafe.implicits.global
+import munit.FunSuite
+import org.scalasteward.core.buildtool.BuildRoot
+import org.scalasteward.core.data.Repo
+import org.scalasteward.core.mock.MockContext.context.*
+import org.scalasteward.core.mock.{MockEffOps, MockState}
+
+class Giter8AlgTest extends FunSuite {
+
+  test("getGiter8BuildRoot: returns BuildRoot when repo name ends with .g8") {
+    val repo = Repo("example", "kafka-streams.g8")
+    val initial = MockState.empty
+    val result = giter8Alg.getGiter8BuildRoot(repo).runA(initial).unsafeRunSync()
+    val expectedBuildRoot = BuildRoot(repo, "src/main/g8")
+    assertEquals(result, Some(expectedBuildRoot))
+  }
+
+  test("getGiter8BuildRoot: returns BuildRoot when src/main/g8 directory exists") {
+    val repo = Repo("example", "kafka-streams")
+    val repoDir = workspaceAlg.repoDir(repo).unsafeRunSync()
+    val initial = MockState.empty
+      .addFiles(repoDir / "src" / "main" / "g8" / "build.sbt" -> "lazy val root = ...")
+      .unsafeRunSync()
+    val result = giter8Alg.getGiter8BuildRoot(repo).runA(initial).unsafeRunSync()
+    val expectedBuildRoot = BuildRoot(repo, "src/main/g8")
+    assertEquals(result, Some(expectedBuildRoot))
+  }
+
+  test("getGiter8BuildRoot: returns None when no giter8 template") {
+    val repo = Repo("example", "regular-project")
+    val initial = MockState.empty
+    val result = giter8Alg.getGiter8BuildRoot(repo).runA(initial).unsafeRunSync()
+    assertEquals(result, None)
+  }
+
+  test("getGiter8BuildRoot: .g8 repo takes precedence over non-existing src/main/g8") {
+    val repo = Repo("example", "my-template.g8")
+    val initial = MockState.empty
+    val result = giter8Alg.getGiter8BuildRoot(repo).runA(initial).unsafeRunSync()
+    val expectedBuildRoot = BuildRoot(repo, "src/main/g8")
+    assertEquals(result, Some(expectedBuildRoot))
+  }
+}

repos.md

@@ -6,9 +6,4 @@ The format is "- $owner/$repo".
 If you want Scala Steward to keep a non-default branch up-to-date, use "- $owner/$repo:$branch".
 All lines that do not start with a hyphen and space are ignored.
 
-- scala-steward-org/mill-plugin
-- scala-steward-org/sbt-plugin
-- scala-steward-org/scala-steward
-- scala-steward-org/test-repo-1
-- scala-steward-org/test-repo-1:scala-cli-test
-- scala-steward-org/test-repo-2
+- monksy/kafka-streams.g8