Skip to content
CAI
Software that uses CAICheck a score

oyvindberg/bleep

47.5

Weak · 7 November 2026

109.9k

lines of production code

Scala

with Java

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Bleep is a high-performance, native-first build system and build server for JVM and Scala ecosystems, designed to replace legacy tools like SBT and Bloop. It provides a unified interface for importing, compiling, and testing projects across Java, Kotlin, Scala, and Quarkus, featuring a native CLI, a BSP-compliant daemon, and an MCP server for AI agent integration. The system emphasizes speed and developer experience through features like incremental build state copying, resource-aware JVM management, and seamless IDE integration via IntelliJ and VS Code.

How it got here

2021–2022 — CLI expansion and BSP migration

23 changes.

This period focused on expanding the bleep CLI with comprehensive build management and server control commands, while migrating the import infrastructure from Bloop to a native bleep-bsp implementation. Significant effort was also directed toward stabilizing the build system through native-image configuration, dependency vendoring, and robust integration testing. Concurrently, the project launched a revamped documentation site and simplified user onboarding with a one-line installer script.

2023–2026 — framework integrations and AI tooling

31 changes.

This period focused on expanding framework support by adding plugins for Quarkus and Spring Boot, alongside a new IntelliJ plugin for IDE integration. It also introduced AI agent capabilities through a Model Context Protocol (MCP) server and a Java-based scripting API for build automation. Underlying these features were significant improvements to the BSP server, including isolated compiler toolchains, resource governance, and new administrative commands for server management.

Features

Add native Bleep BSP server benchmark and visualization tools

Introduced a new benchmark suite for the BSP server that replaces the previous Bloop-based testing with a native Bleep BSP implementation. The suite includes a Bash script (benchmark-bsp.sh) to stress-test the server by concurrently cloning source repositories, performing git cleans, and running compilations across multiple workspaces, while collecting timing data. Additionally, a Python visualization tool (visualize.py) was added to generate an interactive HTML dashboard from the collected metrics, displaying JVM heap/GC stats, CPU load, thread counts, and compilation timelines.

benchmark · high confidence

Added Java-based bleepscript examples

The scripts-java module now includes example scripts written in Java, demonstrating how to extend the BleepScript class to create custom commands. These examples, including Hello, ListProjects, and ShowDeps, illustrate how to access build information, iterate over projects, and handle dependencies within a Java context.

scripts-java · high confidence

Added KSP test processor for code generation integration testing

A new test module (bleep-test-ksp-processor) has been added to support integration testing of Kotlin Symbol Processing (KSP). It includes a ToyProcessor that generates Kotlin and Java classes based on custom annotations (@GenerateKotlin, @GenerateJava) and provides a mechanism to detect processor errors (@ThrowOnMe). This allows the build system's test suite to verify KSP integration, mixed-language compilation, and processor invocation behavior.

bleep-test-ksp-processor · high confidence

Automated documentation builds with version-aware snippet extraction

The documentation site now automatically extracts code snippets from the Java, Kotlin, and Scala source trees and embeds them into the generated site. A new remark plugin replaces the \BLEEP\_LATEST\_VERSION\ placeholder with the actual latest release version derived from git tags, ensuring that documentation always points to the correct dependency version without requiring manual updates or dirty working trees. This change supports the new auto-deployment workflow on pushes to the master branch.

bleep-site/scripts · high confidence

Expanded documentation snippets for scripting, publishing, and framework integration

The documentation now includes new examples for writing and running custom build scripts in Java, Kotlin, and Scala, as well as a ProGuard publishing workflow for shrinking and publishing artifacts. It also demonstrates publishing to plain HTTP Maven repositories and Artifactory, cross-building for Scala 2.13 and 3, and source generation. Additionally, new snippets show how to integrate with Quarkus and Spring Boot, configure build stamps, and structure test projects.

docs-snippets-from-tests · high confidence

Initial project bootstrap and configuration

The repository is initialized with the core configuration files required to build and develop the project. This includes the primary build definition in bleep.yaml, the JSON schema for validation, and the coursier launcher configuration. To ensure consistent behavior across operating systems, .gitattributes is configured to normalize line endings to LF, and .gitignore is updated to exclude build artifacts and IDE state. The project also introduces .scalafmt.conf for Scala code formatting, .javafmt.conf for Java formatting, and .scalafix.conf for import organization. Additionally, git submodules are added to vendor specific sbt plugins and libraries (such as sbt-ci-release, sbt-sonatype, and zinc) into the liberated/ directory, and developer documentation is added via CLAUDE.md.

(repo-wide) · high confidence

Introduce IntelliJ plugin for Bleep build tool

Adds a new IntelliJ plugin that integrates the Bleep build tool into the IDE. The plugin automatically detects projects containing a bleep.yaml file, downloads the correct Bleep binary for the host OS and architecture, and provides a dedicated tool window for selecting projects to mount via BSP. It supports JSON schema validation for bleep.yaml, offers actions to run setup-ide and refresh BSP connections, and automatically triggers a BSP sync when the bleep.yaml file is modified.

intellij-plugin · high confidence

Introduce MCP server for AI agent integration

Adds a new Model Context Protocol (MCP) server that exposes bleep's build, test, and history capabilities to AI agents. The server is stateless and workspace-aware, bootstrapping a fresh build context for every tool call to ensure it always reflects the current state of the project without holding stale in-memory state. It provides tools for compiling, testing, running, and inspecting build history, while filtering out non-actionable TUI progress noise to keep agent context windows efficient. The server runs on stdio and exits cleanly when the client disconnects, allowing a single registration to serve multiple git worktrees.

bleep-cli/src/scala-3 · high confidence

Introduce Quarkus integration for @QuarkusTest, dev mode, and production packaging

Bleep now supports Quarkus applications by generating the serialized application model required for Quarkus bootstrapping, enabling @QuarkusTest, dev mode, and production packaging within bleep workspaces. This change adds the Quarkus plugin implementation (QuarkusAppModel, AppModelAssembler, ModelSpec) to construct the application model from bleep's resolved classpath and workspace layout, and updates the test runner (ForkedTestRunner, JUnitPlatformRunner) to support the Quarkus test framework integration.

_moduleName\2.13 · high confidence

Introduce Quarkus plugin for dev mode, production packaging, and test model generation

This change adds a new Quarkus plugin to the build system, enabling developers to run Quarkus applications in dev mode with live reload (QuarkusRun), produce production fast-jar packages (QuarkusPackage), and generate the serialized application models required for @QuarkusTest execution (QuarkusTestModelGen). The implementation includes a compatibility layer (QuarkusCompat) to handle API differences between Quarkus versions, ensuring the plugin works across supported releases. Documentation snippets demonstrate how to wire these scripts into a project's build configuration.

(repo-wide) · high confidence

Introduce bleepscript: a Java API for writing build automation scripts

Users can now write build automation scripts in Java using the new bleepscript API. This location provides the core framework classes (BleepScript, BleepCodegenScript) and a comprehensive service interface (BleepscriptServices) that exposes build capabilities such as compiling, linking, testing, and publishing (to local Ivy/Maven, folders, resolvers, or Sonatype Central) directly to script authors. The API includes helpers for dependency resolution via Coursier, packaging artifacts into JARs, and managing build paths, allowing scripts to integrate seamlessly with the existing bleep build lifecycle without shelling out to the command line.

bleepscript · high confidence

Introduce dev-mode dependency resolution for forked sourcegen JVMs

Bleep now resolves \build.bleep::\*\ dependencies with \dev:\ versions from local compiled class directories instead of requiring published artifacts. This allows forked sourcegen JVMs to correctly load bleep's own internal modules (such as plugins and test runners) during development, ensuring that resources and transitive dependencies are available on the classpath without needing to publish snapshots.

bleep-core · high confidence

Introduce new test runner with dedicated protocol and suite execution logic

The bleep-test-runner module now includes the core implementation for its test execution engine, specifically the SuiteRunner and TestProtocol classes. SuiteRunner handles the lifecycle of running test suites (both individually and in batches) by loading frameworks, executing tasks, and reporting results, while TestProtocol defines the JSON-based communication format between the bleep parent process and forked test JVMs. This change establishes the foundational mechanics for how tests are discovered, executed, and reported back to the build tool.

bleep-test-runner · high confidence

Introduces nosbt compatibility layer with core IO and utility primitives

Adds a new \bleep-nosbt\ module that provides a compatibility layer for sbt-like functionality. This includes core IO utilities for file operations (create, delete, list, relativize), SHA-1 hashing, and resource management via a \Using\ pattern. It also introduces user interaction primitives (\InteractionService\), logging infrastructure (\Level\, \Logger\), source position tracking, and Ivy credential handling (\Credentials\). These components form the foundational I/O and utility base required for the library management integration.

bleep-nosbt · high confidence

New Spring Boot plugin and example application

This release introduces the \bleep-plugin-spring-boot\ module, providing three core scripts for Spring Boot development: \SpringBootRun\ to fork a JVM and run the application (equivalent to \mvn spring-boot:run\), \SpringBootRepackage\ to build executable fat JARs with optional layered Docker support, and \SpringBootBuildInfo\ to generate \META-INF/build-info.properties\ for the Actuator info endpoint. An accompanying example project (\spring-boot-myapp\) demonstrates these scripts with a Spring Boot application using DuckDB, including configuration for dev and prod profiles.

bleep-plugin-spring-boot, docs-snippets-from-tests/spring-boot-myapp/myapp, docs-snippets-from-tests/spring-boot-myapp/scripts · high confidence

New \`bleep server\` command for managing compile server daemons

Users can now inspect, control, and configure the background compile server (BSP daemon) processes directly from the CLI via the new \bleep server\ command. This includes subcommands to view a live dashboard (\top\), list running servers (\ls\), check detailed status, stop or restart specific or all servers, prune stale directories, view logs, and adjust server configuration knobs (such as parallelism and memory limits) that were previously only editable via YAML files.

bleep-cli/src/scala/bleep · high confidence

New \`bleep server\` subcommands for managing compile servers

This change introduces a comprehensive set of new CLI commands for interacting with compile servers, including \bleep server ls\ to list all servers and their states, \bleep server status\ for detailed daemon information, \bleep server log\ to view daemon logs, \bleep server kill\ to stop servers gracefully or forcefully, \bleep server restart\ to stop and allow fresh spawning, \bleep server prune\ to remove stopped server directories, \bleep server config set\ and \show\ to manage and inspect server configuration settings, and \bleep server top\ which provides a live TUI dashboard for monitoring server activity, CPU, and memory usage.

bleep-cli/src/scala/bleep/commands/server · high confidence

A new developer script, \LinkifyCliMentions\, has been added to the \scripts-dev\ module. When executed via \bleep linkify-cli-mentions\ (after running \bleep gen-cli-docs\), it scans Markdown and MDX files in the \docs/\ directory and automatically converts inline code mentions of \bleep \<command\>\ into clickable links pointing to the corresponding auto-generated CLI reference pages. The script intelligently handles nested subcommands and sub-subcommands, respects existing links to avoid double-linking, and skips content within headings or fenced code blocks to prevent formatting issues.

scripts-dev · high confidence

New asciinema recording harness for demo videos

A new shell script harness (\asciinema-rec\_script\) has been added to the resources directory to facilitate the creation of screencast videos. This tool records shell sessions using asciinema, automatically augmenting the input script with syntax highlighting (via \bat\ or \cat\), simulated typing effects, and formatted comments. It handles ANSI escape codes correctly and allows for configurable recording parameters, enabling the generation of consistent, visually enhanced demo videos.

scripts/src/resources · high confidence

New bleep scripts for documentation, native-image, integration tests, and scalafix

The build system now includes four new executable scripts: \GenDocumentation\ compiles documentation snippet projects and manages the site build (via npm) for local development or deployment; \GenNativeImage\ handles GraalVM native-image compilation with optimized quick-build modes for non-release builds and supports emitting standalone launcher scripts; \It\ runs integration tests against demo projects using a specified native-image binary; and \Scalafix\ applies semanticdb-based code rewrites to the jvm3 project.

scripts/src/scala · high confidence

New build management and project lifecycle commands

This change introduces a suite of new CLI commands for managing build structure and project organization. Users can now create new builds with \bleep build new\ (supporting Java, Kotlin, and Scala), create source directories with \bleep build create-directories\, and inspect build differences against git revisions with \bleep build diff\. Project refactoring is now supported via \bleep build project-rename\, \bleep build project-move\, and \bleep build project-merge-into\. Additional commands include \bleep build invalidated\ for CI-optimized rebuilds by detecting changed sources and config, \bleep build normalize\ to clean up build files, \bleep build reapply-templates\ and \bleep build reinfer-templates\ for template management, and \bleep build update-deps\ for upgrading dependencies. The diff also adds commands for managing the compile server (\compile-server-set-mode\, \compile-server-stop-all\) and configuring authentications (\config-auth-list\, \config-auth-remove\, \config-auth-setup\).

bleep-cli/src/scala/bleep/commands · high confidence

New daemon admin protocol for server status and state copying

The bleep daemon now exposes a new JSON-RPC admin surface (BleepServerAdmin) that allows clients to query server status and copy compiled state between workspaces. This protocol supports methods like \bleep/status\ to retrieve detailed metrics (CPU/memory usage, active operations, cache stats, and configuration) and \bleep/copyState\ to seed a new git worktree with the parent's incremental build baseline. The protocol is versioned and designed to work with older daemons, ensuring that administrative commands like \bleep server ls\ function correctly even when managing legacy server instances.

bleep-bsp-protocol · high confidence

New guided demo showing seeded vs. cold worktree compilation performance

A new demo in the \demo-claude-agents\ directory demonstrates the performance difference between a cold compile and a seeded compile using bleep's \copy-state\ tool. The demo uses a real interactive Claude Code session, driven by an Expect script (\drive.exp\) that automates input to a terminal UI, to orchestrate two subagents: one seeds a fresh git worktree with build state, while the other compiles from scratch. Bleep then compares the timing of both runs, showing that the seeded worktree is significantly faster. The demo includes a fixture script to set up a small Scala project, a shell script to run the interactive session, and documentation explaining the setup and expected results.

demo-claude-agents · high confidence

New isolated compiler toolchains for Kotlin and Scala.js/Scala Native

The bleep-bsp module now includes dedicated compiler bridges and runners for Kotlin (JVM, JS, and Native) and Scala.js/Scala Native. This introduces \IsolatedProcessorsFileManager\ and \IsolatedProcessorsJavaCompiler\ to load annotation processors in a separate classloader, preventing classpath conflicts with the build server. It adds \KotlinJsRunner\ and \KotlinNativeRunner\ to execute compiled artifacts via Node.js or native binaries, and implements \ScalaJs1Bridge\ and \ScalaNative04Bridge\/\ScalaNative05Bridge\ to link Scala.js and Scala Native projects using reflection for version isolation. These components are wired into \ProjectCompiler\ to handle project-level compilation and linking for these specific language targets.

bleep-bsp · high confidence

New local deployment skill with automatic stale process cleanup

A new \deploy-local\ skill has been added to the \.claude\ directory, providing a documented recipe and executable scripts (\deploy.sh\, \stale-processes.sh\) to build, install, and verify a local snapshot of the bleep binary. This deployment process ensures version consistency between the client binary and server jars, and automatically detects and kills stale \bleep mcp-server\ and \BspServerDaemon\ processes that are running outdated code, ensuring the IDE tools always reflect the current build.

.claude · high confidence

One-line install script and site configuration files added

Users can now install bleep with a single command (curl -fsSL https://bleep.build/install \| sh). The installer script supports Linux (x86\_64, arm64) and macOS (arm64), but explicitly blocks installation of versions newer than 1.0.0-M14 on Intel Macs (x86\_64) because those builds are no longer provided. The site also includes a CNAME file pointing to bleep.build and a .nojekyll file to ensure static content is served correctly.

bleep-site/static · high confidence

SbtExportPlugin adds tasks to export build dependencies as JSON

The sbt-export-dependencies module now provides an SBT plugin (SbtExportPlugin) that introduces new tasks to export project dependency information. Users can run exportProject to generate a JSON file for a specific project, or exportAllProjects to generate files for all projects in the build. The exported JSON includes details such as organization, module name, Scala version, library dependencies, project dependencies, and managed sources. The plugin also handles naming conflicts for derived project names (e.g., for test configurations) by appending a separator if a conflict is detected.

sbt-export-dependencies · high confidence

Removals

Removal of legacy bloop file generation infrastructure

The \src/main\ area has removed the entire legacy codebase responsible for parsing \bleep.json\ project files and generating Bloop configuration files. This includes the deletion of the \Main\ entry point, the \CoursierResolver\ for dependency fetching, the \Dep\ and \model\ definitions for project structure, and the \generateBloopFiles\ logic. Additionally, the native-image configuration for \scala-lang\ has been removed, indicating a shift away from the previous build-time initialization strategy for Scala runtime components.

src/main · high confidence

Behavioural changes

BSP client now resolves the build before forwarding to the server

The \bleep bsp\ proxy now acts as a full client that loads and resolves the build (including applying SemanticDB rewrites for IDEs) before connecting to the daemon. This centralizes build resolution and file watching in the proxy process, ensuring the server receives a pre-resolved build and receives notifications when build files change, rather than the server loading the build itself.

bleep-cli/src/scala/bleep/bsp · high confidence

Documentation site revamp with Docusaurus 2 and new content components

The documentation site has been rebuilt using Docusaurus 2, introducing a new landing page with feature highlights and a restructured navigation split into 'Learn' and 'Reference' sections. The site now supports rendering the current version from git tags, includes a script to measure and display build statistics, and adds new React components for displaying code snippets with language tabs and embedding Asciinema terminal recordings.

bleep-site · high confidence

Generated files are now preserved as static resources during import

The build system now copies source and resource files generated by sbt or Maven into the project during import, rather than discarding them. A new codegen script, CopyImportedGeneratedFiles, is added to snapshot tests (bloop, converter, doobie, http4s, javaparser, pekko, playframework, sbt, scalameta, tapir, zio) to copy these kept files from \scripts/resources/\<project\>\ to their respective source and resource directories. This ensures that generated artifacts are available in the imported project, serving as a temporary stand-in until proper generation code is implemented.

(repo-wide) · high confidence

Inline resource generation for bleep-model with write-if-changed optimization

The resource generation logic for the bleep-model project has been moved inline into the scripts-init module, replacing the previous approach where versions were generated into source files. This change ensures that version information is now read directly from the project's dynver stamp, preventing stale values from silently entering the cache key and affecting downstream projects. Additionally, the new implementation includes a write-if-changed mechanism that compares generated content before writing, reducing unnecessary file timestamp updates and improving build stability during local development.

scripts-init · high confidence

Maven import now supports Quarkus test projects and generated source handling

The Maven import process in bleep-cli has been rewritten to better handle complex Maven projects. It now automatically detects Quarkus test projects (identified by dependencies on quarkus-junit5 or quarkus-junit) and wires in the bleep-plugin-quarkus to support QuarkusTestModelGen, dev mode, and packaging scripts. Additionally, the import logic now preserves Maven-generated source files by copying them into a dedicated scripts project, ensuring that generated resources are not lost during the migration. The import also includes improved parsing of effective POMs and dependency lists to ensure accurate project structure and dependency resolution.

bleep-cli/src/scala/bleep/mavenimport · high confidence

New and updated demo casts for agents, copy-state, and diff features

The static demos directory has been updated with new asciinema cast files (\agents.cast\, \copy-state.cast\, \diff.cast\) and modified existing ones (\claude-agents.cast\). These recordings visually demonstrate the new 'agents' feature (showing parallel worktrees and diff-based results), the 'copy-state' feature (showing warm checkouts and history), and the 'diff' feature (showing recorded compile/test runs). The \claude-agents.cast\ file has also been updated to reflect changes in the guided Claude session.

bleep-site/static/demos · high confidence

New site visual identity and navbar mobile drawer fix

The site now features a complete visual overhaul with a 'manifesto' aesthetic, introducing Fraunces for headings, IBM Plex Sans for body text, and JetBrains Mono for code, along with distinct light (paper) and dark (ink) themes. This update also resolves a bug where the mobile navigation drawer was rendered behind the fold by restructuring the navbar's background styling to use a ::before pseudo-element with backdrop-filter, ensuring the fixed-position sidebar remains visible.

bleep-site/src/css · high confidence

Preserve YAML comments when rewriting bleep.yaml

Bleep now retains comments in bleep.yaml when it rewrites the file. This is achieved by introducing a custom YAML emitter (CommentPlacingEmitter) in the model layer that preserves comment placement during serialization, ensuring that user-added documentation and notes are not lost during build updates.

bleep-model · high confidence

Redesigned landing and /why pages with performance metrics and interactive demos

The site now features a completely rewritten landing page (index.js) and a new /why page that serve as the primary entry points for users. The landing page introduces a 'build-as-data' narrative, highlighting the tool's simplicity and suitability for agentic development, while the /why page argues for the product's speed by displaying measured performance statistics (such as CLI startup time and worktree fork times) sourced from build-stats.json. Both pages utilize a shared design system with scroll-triggered reveal animations, cursor-tracked hero effects, and embedded asciinema player components to demonstrate agent interactions and test runs.

bleep-site/src/pages · high confidence

Refactor import logic and replace Bloop with native bleep-bsp

The import process now uses a native bleep-bsp implementation instead of Bloop, with the build JVM pinned to Temurin (minimum Java 17) to ensure compatibility with older Scala versions. Imported generated files are preserved as static resources and copied via a generated Java sourcegen script until native generation is implemented. Additionally, the system now filters out cross-projects using unsupported Scala versions (keeping only 2.12, 2.13, and 3.x) and includes new model conversion utilities for Bloop configuration types.

bleep-cli/src/scala/bleep/internal · high confidence

Simplified sbt import with unified dependency schema and enhanced filtering

The sbt import process now uses a unified JSON schema for dependency data, replacing the previous external \sbt-export-dependencies\ tool with an internal \bleep.sbtexport.Lm\ module that mirrors sbt's library management types. This change enables more robust import filtering, allowing users to exclude specific projects (including their downstream dependencies) and filter by Scala version or platform during the import. The import logic also now handles sbt 2 builds via a server mode and improves cross-project handling by detecting and warning about case-insensitive filesystem conflicts.

bleep-cli/src/scala/bleep/sbtimport · high confidence

Structured BSP protocol types replace stringly-typed events

The bleep-bsp protocol now uses strongly-typed sealed traits (e.g., CompileStatus, TestStatus, SuiteOutcome, CompilePhase) instead of raw strings for build events. This ensures clients like IDEs and the TUI receive precise, unambiguous signals for compilation phases, test outcomes, and process exits, eliminating previous ambiguities where different states (like empty suites vs. errors) were indistinguishable.

repository · high confidence

Fixes

Fix native image crashes when launching external processes

The bleep CLI no longer crashes with a NoClassDefFoundError when running as a GraalVM native image and attempting to launch a child process (such as during version hand-off or BSP operations). This was caused by an unresolved reference to an internal GraalVM package in the previous implementation; the fix replaces it with a custom implementation using only public C interop APIs, ensuring stable execution on macOS and Linux.

bleep-cli/src/java · high confidence

Native-image configuration for bleep-cli resources

Added native-image reachability, reflection, JNI, and resource configuration files for bleep-cli to ensure the GraalVM binary includes required classes and libraries. This prevents runtime crashes caused by missing classes (e.g., crossterm terminal events, BSP response errors) and missing native libraries (e.g., swoval, crossterm) or resources (e.g., version stamps). It also registers foreign function interface (FFI) downcalls for process memory monitoring and Windows user path resolution, which are necessary for features like \bleep server top\ and proper startup on Windows.

bleep-cli/src/resources · high confidence

Test coverage

Added integration tests for GreetingResource; Added snapshot test for main greeting logic; Added tests for BSP server internals and state management; Added tests for JVM fork cost modeling and machine resource governance; Added tests for JVM pool lifecycle, exit attribution, and output capture; Added unit and integration tests for the Spring Boot myapp example; New integration tests for BSP analysis, compilation, and diagnostics; New integration tests for annotation processing, batch test execution, and dependency scoping; Removed test infrastructure and snapshot test for project parsing; Updated snapshot test inputs for Bloop project configurations.

Dependencies

Introduce IntelliJ plugin and Docusaurus-based documentation site

This change adds the build configuration for a new IntelliJ IDEA plugin (bleep-intellij-plugin) and the dependency manifest for the Bleep documentation site (bleep-site). The IntelliJ plugin is built with Kotlin 2.1.0 and Gradle 8.13, targeting IntelliJ Platform 2025.3 and Java 21, and includes dependencies for YAML and JSON parsing. The documentation site is configured with Docusaurus 3.10.1 and React 18.2.0, requiring Node.js 18 or higher. Additionally, the legacy SBT build file (build.sbt) for the main project has been removed.

(dependencies) · high confidence

Vendor external build tools and libraries into the \`liberated\` directory

The \liberated\ area now contains submodules for several external dependencies and tools, including \librarymanagement\, \mdoc\, \mill-scalafix\, \sbt-ci-release\, \sbt-dynver\, \sbt-git-versioning\, \sbt-jni\, \sbt-native-image\, \sbt-pgp\, \sbt-sonatype\, \sbt-tpolecat\, and \zinc\. This change integrates these components directly into the project tree, allowing the build system to vendor and manage these specific versions of third-party libraries and plugins.

liberated · high confidence

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

How this codebase got here

Score

  • CAI 44 → 48 (+3.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 35 → 35 (+0.0)
  • Architecture 100 → 100 (+0.0)
  • Maturity 38 → 56 (+18.4)
  • Readiness 52 → 52 (+0.0)
  • Security 70 → 73 (+3.5)
  • Performance 72 → 60 (-11.9)

Resolved (6)

  • High CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • High CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • High CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Low CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Medium CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Medium CVE: [GHSA redacted] (bleep-site/package-lock.json)

New (6)

  • High CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • High CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Low CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Medium CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Medium CVE: [GHSA redacted] (bleep-site/package-lock.json)
  • Medium CVE: [GHSA redacted] (bleep-site/package-lock.json)

Architecture

  • Unchanged — 0 containers · 2 contexts · 0 edges

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

Survey your own repository

oyvindberg/bleep 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.

About this page

  • The score is its most recent published measurement, taken on 7 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 4fea48f63fe55b0d2ae47019687dd7df2036cd2e — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-5f8314471808.