foundweekends/giter8

This system is Giter8, a template engine and scaffolding tool designed to generate project structures from reusable templates. It supports fetching templates from local directories, Git repositories, and Maven metadata, while providing a command-line interface and an SBT plugin for integration. The tool handles template rendering with custom property resolution, file filtering, and permission preservation, enabling developers to quickly scaffold new projects with consistent configurations.

6 changes.

This period focused on modernizing the project's infrastructure by migrating the build system from legacy SBT versions to sbt 2, enabling support for Scala 3, and standardizing development tooling. The work also involved removing deprecated GitHub API integration and refactoring the core application structure to establish a new launcher and processor architecture for template execution.

8 changes.

The project modernized its core template engine by introducing Maven metadata resolution and integrating StringTemplate 4, while replacing deprecated functions like ls(). Concurrently, the SBT plugin was restructured for Scala 2/3 compatibility and updated to support sbt 1.x, including the adoption of explicit main methods in generated templates to align with newer Scala standards.

8 changes.

This period focused on building the foundational components of the Giter8 project, including the core library for template rendering and version handling, as well as the CLI infrastructure for Git-based template fetching. Comprehensive test suites were developed to validate core functionality, file filtering, and launcher integration, ensuring the system correctly processes templates and resolves dependencies.

This change introduces the core infrastructure for fetching templates from Git repositories, including support for local paths, remote URLs, and GitHub shorthand. It adds a new command-line interface with options to specify branches (-b), tags (-t), subdirectories (-d), and output locations (-o), along with a --known-hosts flag for custom SSH configurations. Authentication is handled via an interactive console provider for usernames and passwords, and SSH connections utilize a custom session factory that respects known hosts files, enabling secure cloning of private repositories.

cli-git/src/main · high confidence

This change adds the foundational source files for the Giter8 library, including \VersionNumber\ for parsing and ordering semantic versions, \Truthy\ and \AugmentedString\ for template value evaluation, \JGitIgnore\ for applying \.gitignore\-style exclusion rules to generated files, \MavenHelper\ for fetching artifact metadata from Maven Central, \Ls\ for parsing repository specifications, and \TemplateRenderer\ as the interface for executing template generation. These components collectively enable the core functionality of resolving dependencies, filtering files, and rendering project templates.

library/src/main/scala/giter8 · high confidence

A new LauncherMain object has been added to the launcher module, serving as the explicit entry point for the application. It initializes the logging level to SEVERE and delegates execution to a LauncherProcessor, which handles template processing, artifact resolution via Coursier, and classloader-based execution of the Giter8 core logic.

launcher/src/main · high confidence

The application now includes a new \Giter8\ class that serves as the main entry point for both the sbt plugin interface (implementing \xsbti.AppMain\) and the command-line runner. This component initializes the \AppProcessor\, which delegates template rendering tasks to \G8TemplateRenderer\. This change establishes the core wiring for executing templates from a specified directory with provided arguments and output settings.

app/src · high confidence

The library now supports resolving template properties from Maven repositories using a new \maven()\ syntax (e.g., \maven(org,name,stable)\) defined in \maven.scala\, which parses \maven-metadata.xml\ to find latest or stable versions. This replaces the deprecated \ls()\ function. The core \g8.scala\ file establishes the template application logic, including property resolution via \ValueF\, StringTemplate 4 integration with custom renderers, and file writing that preserves POSIX permissions and executable flags.

library/src/main/scala · high confidence

The \Giter8\ class, which previously implemented template retrieval by directly calling the deprecated GitHub API v2, has been removed from the codebase. This eliminates the functionality that allowed users to fetch and apply templates by specifying a repository name (optionally with a \.g8\ suffix) via the old JSON-based HTTP interface.

src/main/scala · high confidence

The default launch configuration for Giter8 templates has been updated to use version 0.18.0 of the giter8 application, targeting Scala 2.12.21, and configured to resolve dependencies from local and Maven Central repositories.

src/main/conscript · high confidence

The project license has been changed to Apache 2.0, and the README has been updated to reflect the new foundweekends ownership and the Apache 2.0 license terms. Development tooling has been standardized by adding a .scalafmt.conf file (configuring Scala 2.13/3 dialects and 120-column width) and a .scala-steward.conf file (managing dependency update cooldowns, limits, and pinned versions for jgit and slf4j). Additionally, the .gitignore has been expanded to exclude modern IDE and build tool artifacts (IntelliJ, Metals, Bloop, VS Code), and .git-blame-ignore-revs has been introduced to ignore automated scalafmt reformatting commits.

(repo-wide) · high confidence

The legacy SBT 0.11 build definition file (project/build/project.scala) has been removed. This file previously configured the project to depend on the SBT launcher interface and the Dispatch library for JSON handling. Its removal indicates a shift away from this specific build configuration, likely as part of the broader migration to a newer build system or project structure.

project/build · medium confidence

The plugin source has been reorganized to support both Scala 2 and Scala 3 through dedicated compatibility objects (\Giter8PluginCompat\), while consolidating the main plugin logic into \Giter8Plugin.scala\. This change introduces support for copying scaffold files from the \scaffolds\ directory during template generation and refines the test script resolution logic to prioritize specific file names like \test.script\ or \g8.test\. Additionally, deprecated compatibility shims (\SBTCompat\, \g8ScriptedCompat\) are retained for backward compatibility but marked for removal, and property reading now explicitly uses \JavaConverters\.

plugin/src/main · high confidence

The \g8Scaffold\ command in the \scaffold\ module now accepts a \--force\ flag, allowing users to overwrite existing generated files when running scaffolding templates. This behavioral change is implemented in \ScaffoldPlugin.scala\ and verified by scripted tests that confirm the \--force\ option successfully replaces existing controller files.

scaffold/src · high confidence

The root-layout template now generates a Scala entry point using an explicit \main\ method in the \Main\ object instead of extending \scala.App\. This change ensures compatibility with newer Scala versions that deprecate \scala.App\ and provides a more standard application structure for generated projects.

plugin/src/sbt-test/giter8/root-layout · high confidence

The simple Giter8 template located in the sbt-test plugin directory has been updated to use the Apache 2.0 license instead of the previous license. Additionally, the template's default properties now define dependencies using the new 'maven' syntax (e.g., \maven(net.databinder, unfiltered\_2.11)\), and the generated Scala source code has been adjusted to use an explicit \main\ method rather than extending \scala.App\.

plugin/src/sbt-test/giter8/simple/src · high confidence

Added comprehensive test suite for Giter8 library; Added integration tests for the launcher; Added property-based tests for string formatting conversions; Added scripted tests for the Giter8 plugin; Added test resources for file conditionals and simple SBT project templates; Added test template for Giter8 without name; Added unit tests for Git repository parsing and cloning logic.

The build system has been upgraded from sbt 0.7.4 to sbt 2.0.8, enabling support for Scala 3.8.4 alongside Scala 2.12.21 and 2.13.18. Core library dependencies have been updated, including JGit 5.13.5 (with sshd-sftp excluded to address security advisory [GHSA redacted]), Commons IO 2.22.0, and ScalaTest 3.2.20. The build structure was refactored into separate files (Dependencies.scala, G8SitePlugin.scala, Publish.scala) to manage versioning, site generation, and Sonatype publishing more cleanly.

project · high confidence

The project's build definition has been updated to use Scala 2.12 as the primary version and sbt 1.x (specifically 1.9.9 for Scala 2.12) as the build tool version. This change affects the core build configuration and ensures compatibility with modern sbt versions, while maintaining support for Scala 3 and Scala 2.13 in specific modules.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 46 → 55 (+9.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 97 (-2.8)
• Architecture 99 (new)
• Maturity 54 → 42 (-11.5)
• Readiness 29 → 51 (+21.8)
• Security 59 → 70 (+10.9)

• Consequences/trade-offs are absent despite a clear decision: the body describes scaffolding plugin usage and scaffold directory structure but never addresses trade-offs such as how .g8 directories interact with existing templates or whether name fields conflict with template names (docs/ko/04/00.md)
• Consequences/trade-offs are cut by a clip marker and not flagged as missing; only context/problem and an explicit decision (the .g8 repo-name convention) are present (docs/ja/02.md)
• Context/problem is absent (no "Why adopt Conscript?" or "What problem does this solve?"); decision is mostly installation commands with no consequences/trade-offs (docs/ko/01.md)
• Context/problem is present (Conscript setup for Giter8/Scala tooling), but the explicit decision and consequences/trade-offs are absent; only installation commands are shown (docs/ja/01.md)
• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No automated tests
• No consequences/trade-offs section (e.g. template persistence across projects, .g8 dir ownership) (docs/04/00.md)
• No consequences/trade-offs section (e.g. template repo growth, URL vs .g8 file preference) (docs/ko/02.md)
• No consequences/trade-offs section describing the output's purpose or any constraints on its use (docs/ko/00.md)
• No context/problem (why Giter8 matters) and no consequences/trade-offs (docs/00.md)
• No exposed public API
• …and 4 more

• Duplicated block (14–15 lines × 2) (library/src/main/scala/giter8/MavenHelper.scala)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No SBOM
• No build provenance
• Off-boarding risk: anonymized user #1
• Orphaned files with no living knowledge
• Runner.run (cognitive 25) (cli-git/src/main/scala/Runner.scala)
• TooManyMethods: G8 (library/src/main/scala/g8.scala)
• Unpinned build actions
• Workflow token permissions not restricted

• 15 commits — 15 feature/other, 0 fixes

• .github/workflows — 4 commits
• project/Dependencies.scala — 3 commits
• project/build.properties — 3 commits
• (repo) — 2 commits
• project/plugins.sbt — 2 commits
• (root) — 1 commit

• change: Merge pull request #1102 from foundweekends/dependabot/github_actions/scala-steward-org/scala-steward-action-2.95.0
• change: Merge pull request #1107 from foundweekends/update/sbt-2.0.5
• change: Update io to 1.13.0
• change: Update sbt to 2.0.5
• change: Update sbt to 2.0.7
• change: Update sbt to 2.0.8
• change: Update sbt-pgp to 2.3.2
• change: Update sbt-scalafmt to 2.6.2
• change: Update scalacheck to 1.20.0
• change: Update scalafmt-core to 3.11.5
• change: build(deps): bump JamesIves/github-pages-deploy-action
• change: build(deps): bump actions/setup-java from 5 to 6
• change: build(deps): bump scala-steward-org/scala-steward-action
• change: build(deps): bump scala-steward-org/scala-steward-action
• change: sbt 2.0.8

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

foundweekends/giter8 was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.