Rename project to Sloth

Author: lbialy

AGENT_ARCH.md

@@ -1,6 +1,6 @@
-# LazyValGrade Agent Architecture: A Catalog of Weird Shit
+# Sloth Agent Architecture: A Catalog of Weird Shit
 
-This document describes the non-obvious design decisions, workarounds, and architectural quirks in the LazyValGrade java agent. If you're reading this, you're either maintaining this codebase or morbidly curious about what it takes to rewrite bytecode at class-load time inside a running JVM.
+This document describes the non-obvious design decisions, workarounds, and architectural quirks in the Sloth java agent. If you're reading this, you're either maintaining this codebase or morbidly curious about what it takes to rewrite bytecode at class-load time inside a running JVM.
 
 ## Table of Contents
 
@@ -34,7 +34,7 @@ The agent's own dependencies -- including the Scala standard library -- are comp
 
 The pipeline:
 1. Build the CLI jar (which contains the patcher)
-2. Run the CLI patcher against each dependency JAR: `java -cp <cliJar + deps> lazyvalgrade.cli.Main <depJar>`
+2. Run the CLI patcher against each dependency JAR: `java -cp <cliJar + deps> sloth.cli.Main <depJar>`
 3. Swap the patched JARs into the agent's assembly classpath
 
 This is the `processDeps` task. The agent literally patches itself with itself.
@@ -47,9 +47,9 @@ The `DEBUG_AGENT_ASSEMBLY` environment variable enables verbose logging of this
 
 ## 2. Anti-Shading String Construction
 
-**Files:** `LazyValGradeTransformer.scala` (line 28), `BytecodePatcher.scala` (lines 50-69)
+**Files:** `SlothTransformer.scala` (line 28), `BytecodePatcher.scala` (lines 50-69)
 
-sbt-assembly shade rules rewrite all `scala.**` references to `lazyvalgrade.shaded.scala.**`. But the patcher needs to match and generate references to the *application's* unshaded `scala.runtime.LazyVals$`, not the agent's own shaded copy.
+sbt-assembly shade rules rewrite all `scala.**` references to `sloth.shaded.scala.**`. But the patcher needs to match and generate references to the *application's* unshaded `scala.runtime.LazyVals$`, not the agent's own shaded copy.
 
 Two different workarounds are used, for two different reasons:
 
@@ -89,7 +89,7 @@ The `isAssignableFrom` method reimplements the full interface-and-superclass che
 
 ## 4. Companion Pair Buffering
 
-**File:** `LazyValGradeTransformer.scala` (lines 33, 54-58, 126-136)
+**File:** `SlothTransformer.scala` (lines 33, 54-58, 126-136)
 
 Companion pairs (`Foo$` and `Foo`) must be patched together because OFFSET fields can live in the companion class while the `lzyINIT` methods live in the companion object. But the JVM's `ClassFileTransformer` only provides one class at a time.
 
@@ -109,7 +109,7 @@ The solution uses a `ConcurrentHashMap` as a cross-load buffer:
 
 ## 5. The Never-Throw Rule (With One Exception)
 
-**File:** `LazyValGradeTransformer.scala` (lines 151-164)
+**File:** `SlothTransformer.scala` (lines 151-164)
 
 A `ClassFileTransformer` must never throw -- returning `null` means "leave unchanged." The catch block catches `Throwable` and returns `null`.
 
@@ -119,15 +119,15 @@ A `ClassFileTransformer` must never throw -- returning `null` means "leave uncha
 
 ## 6. Double-Attach Guard
 
-**File:** `LazyValGradeAgent.scala` (lines 20-29)
+**File:** `SlothAgent.scala` (lines 20-29)
 
 An `AtomicInteger` detects if `premain` is called more than once, which happens if `-javaagent` is specified alongside `JAVA_TOOL_OPTIONS` containing the same agent. On the second call, it throws a `RuntimeException` to prevent duplicate transformers that would double-patch classfiles. The error message specifically tells the user to remove one of the two agent specifications.
 
 ---
 
 ## 7. Fast-Path Field Scanning
 
-**File:** `LazyValGradeTransformer.scala` (lines 183-212)
+**File:** `SlothTransformer.scala` (lines 183-212)
 
 Before doing any real work, the transformer runs a lightweight ASM pass with `SKIP_CODE | SKIP_DEBUG` that only visits field declarations. It short-circuits as soon as it finds either:
 - A `$lzy` field (but NOT `$lzyHandle` -- that indicates 3.8+ format, already good)
@@ -139,7 +139,7 @@ This avoids the cost of full parsing, companion loading, and group analysis for
 
 ## 8. getResourceAsStream: Pure I/O, Not Class Loading
 
-**File:** `LazyValGradeTransformer.scala` (lines 81-100)
+**File:** `SlothTransformer.scala` (lines 81-100)
 
 The companion's bytes are loaded via `loader.getResourceAsStream(name + ".class")` rather than `Class.forName` or `loadClass`. This is explicitly noted as "pure I/O, no class definition" because `loadClass` would:
 1. Trigger the transformer recursively
@@ -257,9 +257,9 @@ The agent shades *all* of its dependencies and itself:
 - `scribe.**` -- logging library
 - `perfolation.**`, `moduload.**`, `sourcecode.**` -- scribe's transitive dependencies
 - `com.lihaoyi.**`, `os.**`, `geny.**` -- os-lib and its dependencies
-- `lazyvalgrade.**` -- the entire lazyvalgrade itself
+- `sloth.**` -- the entire sloth itself
 
-This is necessary because the agent runs in the application's JVM and cannot conflict with the application's own versions of these libraries. But it creates the anti-shading problems described in section 2, and is why the self-patching build (section 1) exists. Self-shading of the `lazyvalgrade.**` package is only really necessary for agent to be able to run in its own tests.
+This is necessary because the agent runs in the application's JVM and cannot conflict with the application's own versions of these libraries. But it creates the anti-shading problems described in section 2, and is why the self-patching build (section 1) exists. Self-shading of the `sloth.**` package is only really necessary for agent to be able to run in its own tests.
 
 ---
 
@@ -281,9 +281,9 @@ This is why `sbt test` is slow and the CLAUDE.md instructions say to always use
 
 ## 18. Trace-Level Byte Dumping
 
-**File:** `LazyValGradeTransformer.scala` (lines 167-180)
+**File:** `SlothTransformer.scala` (lines 167-180)
 
-At trace log level (`-javaagent:agent.jar=trace`), the transformer dumps every patched class's bytes to `/tmp/lazyvalgrade-dump-<pid>-<name>.class`. The filename sanitizes `$` and `.` to `_`. These dumps happen even on success and are purely for post-mortem `javap` inspection.
+At trace log level (`-javaagent:agent.jar=trace`), the transformer dumps every patched class's bytes to `/tmp/sloth-dump-<pid>-<name>.class`. The filename sanitizes `$` and `.` to `_`. These dumps happen even on success and are purely for post-mortem `javap` inspection.
 
 ---
 

CLAUDE.md

@@ -1,6 +1,6 @@
 # Claude Code Development Guide
 
-This document contains information for Claude Code (or other AI assistants) working on the lazyvalgrade project.
+This document contains information for Claude Code (or other AI assistants) working on the sloth project.
 
 ## Project Structure
 
@@ -33,8 +33,8 @@ SELECT_EXAMPLE=simple-lazy-val,class-lazy-val sbt compileExamplesWithPatching
 
 # Or run the assembly directly
 sbt testops/assembly
-java -jar testops/target/scala-3.3.8/lazyvalgrade-testops.jar
-java -jar testops/target/scala-3.3.8/lazyvalgrade-testops.jar --patch
+java -jar testops/target/scala-3.3.8/sloth-testops.jar
+java -jar testops/target/scala-3.3.8/sloth-testops.jar --patch
 ```
 
 **What it does:**
@@ -132,10 +132,10 @@ The `sbt test` invocations in the filtering examples below are illustrative —
 
 ```bash
 # Run a specific suite with filtering (preferred). Detection lives in tests-jdk9:
-SELECT_EXAMPLE=simple-lazy-val sbt "testsJdk9/testOnly lazyvalgrade.LazyValDetectionTests"
+SELECT_EXAMPLE=simple-lazy-val sbt "testsJdk9/testOnly sloth.LazyValDetectionTests"
 
 # A single example's runtime behaviour (warning suite) lives in tests-jdk25:
-SELECT_EXAMPLE=companion-object-lazy-val sbt "testsJdk25/testOnly lazyvalgrade.BytecodePatchingTests"
+SELECT_EXAMPLE=companion-object-lazy-val sbt "testsJdk25/testOnly sloth.BytecodePatchingTests"
 ```
 
 ### Filtering Examples and Scala Versions
@@ -152,7 +152,7 @@ SELECT_EXAMPLE=simple-lazy-val sbt test
 SELECT_EXAMPLE=simple-lazy-val,class-lazy-val sbt test
 
 # Run specific test suite with filtering
-SELECT_EXAMPLE=companion-object-lazy-val sbt "testsJdk25/testOnly lazyvalgrade.BytecodePatchingTests"
+SELECT_EXAMPLE=companion-object-lazy-val sbt "testsJdk25/testOnly sloth.BytecodePatchingTests"
 
 # Without SELECT_EXAMPLE, all examples are tested (default behavior)
 sbt test
@@ -168,7 +168,7 @@ ONLY_SCALA_VERSIONS=3.1.3,3.3.0 sbt test
 SELECT_EXAMPLE=simple-lazy-val ONLY_SCALA_VERSIONS=3.3.0,3.4.3 sbt test
 
 # Test a problematic version in isolation
-ONLY_SCALA_VERSIONS=3.3.0 sbt "testsJdk9/testOnly lazyvalgrade.LazyValDetectionTests"
+ONLY_SCALA_VERSIONS=3.3.0 sbt "testsJdk9/testOnly sloth.LazyValDetectionTests"
 ```
 
 #### INSPECT_BYTECODE - Enable bytecode inspection on test failures
@@ -185,7 +185,7 @@ INSPECT_BYTECODE=true SELECT_EXAMPLE=multiple-lazy-vals ONLY_SCALA_VERSIONS=3.1.
 
 # Debug a specific test with full bytecode output
 INSPECT_BYTECODE=1 SELECT_EXAMPLE=simple-lazy-val ONLY_SCALA_VERSIONS=3.3.0 \
-  sbt "testsJdk9/testOnly lazyvalgrade.LazyValDetectionTests"
+  sbt "testsJdk9/testOnly sloth.LazyValDetectionTests"
 ```
 
 **INSPECT_BYTECODE accepts:** `true`, `1`, `yes` (case insensitive)
@@ -213,11 +213,11 @@ sbt compile
 
 # Build CLI assembly
 sbt cli/assembly
-# Output: cli/target/scala-3.3.8/lazyvalgrade.jar
+# Output: cli/target/scala-3.3.8/sloth.jar
 
 # Build testops assembly
 sbt testops/assembly
-# Output: testops/target/scala-3.3.8/lazyvalgrade-testops.jar
+# Output: testops/target/scala-3.3.8/sloth-testops.jar
 ```
 
 ## Important Notes

README.md

@@ -80,7 +80,7 @@ The fastest way to test whether your Scala 3 project works on JDK 26+ is the jav
 sbt agentInstall
 ```
 
-This places the agent JAR at `~/.lazyvalgrade/agent.jar`.
+This places the agent JAR at `~/.sloth/agent.jar`.
 
 ### Wrapper Scripts
 
@@ -111,23 +111,23 @@ scn repl .
 For any JVM tool, set `JAVA_TOOL_OPTIONS` to inject the agent globally:
 
 ```bash
-export JAVA_TOOL_OPTIONS="-javaagent:$HOME/.lazyvalgrade/agent.jar"
+export JAVA_TOOL_OPTIONS="-javaagent:$HOME/.sloth/agent.jar"
 ```
 
 This covers any JVM process launched in that shell -- sbt, scala-cli, Mill, Gradle, plain `java`, etc. The agent automatically detects and patches Scala 3.0-3.7.x lazy val bytecode at class-load time.
 
 For a single invocation without environment variables:
 
 ```bash
-java -javaagent:$HOME/.lazyvalgrade/agent.jar -jar your-app.jar
+java -javaagent:$HOME/.sloth/agent.jar -jar your-app.jar
 ```
 
 ### Agent Options
 
 Options are passed after `=` in the `-javaagent:` argument (comma-separated):
 
 ```bash
-java -javaagent:$HOME/.lazyvalgrade/agent.jar=verbose -jar your-app.jar
+java -javaagent:$HOME/.sloth/agent.jar=verbose -jar your-app.jar
 ```
 
 - `verbose` -- log patched classes to stderr (Debug level)
@@ -144,7 +144,7 @@ java -javaagent:$HOME/.lazyvalgrade/agent.jar=verbose -jar your-app.jar
 sbt cli/assembly
 
 # Patch all classfiles in a directory (in-place)
-java -jar cli/target/scala-3.8.1/lazyvalgrade.jar <directory>
+java -jar cli/target/scala-3.8.1/sloth.jar <directory>
 ```
 
 The CLI recursively finds all `.class` files in the given directory, detects Scala 3.0-3.7.x lazy val implementations, and rewrites them to the 3.8+ VarHandle-based format. Use this for producing patched artifacts in build pipelines (assembly JARs, Docker images, etc.).
@@ -156,7 +156,7 @@ The CLI recursively finds all `.class` files in the given directory, detects Sca
 sbt agentInstall
 
 # Run any JVM application with the agent
-java -javaagent:$HOME/.lazyvalgrade/agent.jar -jar your-app.jar
+java -javaagent:$HOME/.sloth/agent.jar -jar your-app.jar
 ```
 
 The agent intercepts class loading, detects Scala 3.0-3.7.x lazy val bytecode, and rewrites it to the 3.8+ format before the class is loaded. No changes to application code or build required.

SEMANTIC_COMPARISON.md

@@ -45,8 +45,8 @@ This comparison ignores all bytecode differences except lazy val implementation
 ## Usage
 
 ```scala
-import lazyvalgrade.classfile.{ClassfileParser, ClassInfo}
-import lazyvalgrade.lazyval.{SemanticLazyValComparator, LazyValFormatter}
+import sloth.classfile.{ClassfileParser, ClassInfo}
+import sloth.lazyval.{SemanticLazyValComparator, LazyValFormatter}
 
 // Parse two classfiles (same source, different Scala versions)
 val bytes1: Array[Byte] = ??? // From Scala 3.3

…ala/lazyvalgrade/agent/AgentConfig.scala …main/scala/sloth/agent/AgentConfig.scalaagent/src/main/scala/lazyvalgrade/agent/AgentConfig.scala renamed to agent/src/main/scala/sloth/agent/AgentConfig.scala agent/src/main/scala/lazyvalgrade/agent/AgentConfig.scala renamed to agent/src/main/scala/sloth/agent/AgentConfig.scala

@@ -1,6 +1,6 @@
-package lazyvalgrade.agent
+package sloth.agent
 
-/** Configuration for the LazyValGrade java agent.
+/** Configuration for the Sloth java agent.
   *
   * Parsed from the agent arguments string (comma-separated key=value pairs).
   *

…zyvalgrade/agent/LazyValGradeAgent.scala …/main/scala/sloth/agent/SlothAgent.scalaagent/src/main/scala/lazyvalgrade/agent/LazyValGradeAgent.scala renamed to agent/src/main/scala/sloth/agent/SlothAgent.scala agent/src/main/scala/lazyvalgrade/agent/LazyValGradeAgent.scala renamed to agent/src/main/scala/sloth/agent/SlothAgent.scala

@@ -1,24 +1,24 @@
-package lazyvalgrade.agent
+package sloth.agent
 
 import java.lang.instrument.Instrumentation
 
-/** Java agent entry point for LazyValGrade.
+/** Java agent entry point for Sloth.
   *
   * Patches Scala 3.0-3.7 lazy val bytecode at class-load time to use
   * VarHandle-based implementation (3.8+ format), avoiding sun.misc.Unsafe.
   *
-  * Usage: java -javaagent:lazyvalgrade-agent.jar[=options] -jar app.jar
+  * Usage: java -javaagent:sloth-agent.jar[=options] -jar app.jar
   *
   * Options (comma-separated):
   *   - verbose: Log patched classes and internals to stderr (Debug level)
   *   - trace: Log everything including byte dumps to stderr (Trace level)
   *   - include=com.example.: Only transform matching packages
   *   - exclude=com.example.internal.: Skip matching packages
   */
-object LazyValGradeAgent {
+object SlothAgent {
 
   /** Log prefix constructed to survive sbt-assembly shade rules. */
-  val logPrefix: String = Array("[lazy", "val", "grade]").mkString
+  val logPrefix: String = Array("[sl", "oth]").mkString
 
   private val instanceCounter = new java.util.concurrent.atomic.AtomicInteger(0)
 
@@ -44,7 +44,7 @@ object LazyValGradeAgent {
       )
       .replace()
 
-    val transformer = new LazyValGradeTransformer(config)
+    val transformer = new SlothTransformer(config)
     inst.addTransformer(transformer)
 
     scribe.info(s"$logPrefix Agent installed")

…rade/agent/LazyValGradeTransformer.scala …scala/sloth/agent/SlothTransformer.scalaagent/src/main/scala/lazyvalgrade/agent/LazyValGradeTransformer.scala renamed to agent/src/main/scala/sloth/agent/SlothTransformer.scala agent/src/main/scala/lazyvalgrade/agent/LazyValGradeTransformer.scala renamed to agent/src/main/scala/sloth/agent/SlothTransformer.scala

@@ -1,11 +1,11 @@
-package lazyvalgrade.agent
+package sloth.agent
 
 import java.lang.instrument.ClassFileTransformer
 import java.security.ProtectionDomain
 import java.util.concurrent.ConcurrentHashMap
 import org.objectweb.asm.{ClassReader, ClassVisitor, FieldVisitor, Opcodes}
-import lazyvalgrade.analysis.LazyValAnalyzer
-import lazyvalgrade.patching.BytecodePatcher
+import sloth.analysis.LazyValAnalyzer
+import sloth.patching.BytecodePatcher
 
 /** ClassFileTransformer that patches Scala 3.0-3.7 lazy val bytecode at load time.
   *
@@ -15,7 +15,7 @@ import lazyvalgrade.patching.BytecodePatcher
   * (pure I/O, no class loading) and both are patched together. The companion's
   * patched bytes are buffered for when it actually loads.
   */
-class LazyValGradeTransformer(config: AgentConfig) extends ClassFileTransformer {
+class SlothTransformer(config: AgentConfig) extends ClassFileTransformer {
 
   /** Packages to always skip (JDK internals, our own code, Scala runtime).
     * NOTE: String literals for our own package and scala/runtime/ are constructed
@@ -24,7 +24,7 @@ class LazyValGradeTransformer(config: AgentConfig) extends ClassFileTransformer
     */
   private val skipPrefixes = Array(
     "java/", "javax/", "jdk/", "sun/", "com/sun/",
-    new StringBuilder("lazy").append("valgrade/").toString,
+    new StringBuilder("sl").append("oth/").toString,
     new StringBuilder("sca").append("la/runtime/").toString
   )
 
@@ -142,15 +142,15 @@ class LazyValGradeTransformer(config: AgentConfig) extends ClassFileTransformer
 
             case Some(BytecodePatcher.PatchResult.Failed(error)) =>
               scribe.error(s"FATAL: Failed to patch $dotName:\n$error")
-              throw new lazyvalgrade.patching.LazyValPatchingException(s"Failed to patch $dotName:\n$error")
+              throw new sloth.patching.LazyValPatchingException(s"Failed to patch $dotName:\n$error")
 
             case None =>
               scribe.debug(s"  no groups to patch")
               null
           }
       }
     } catch {
-      case t: lazyvalgrade.patching.LazyValPatchingException =>
+      case t: sloth.patching.LazyValPatchingException =>
         // Re-throw diagnostic exceptions — the class must not load with broken bytecode
         throw t
       case t: Throwable =>
@@ -171,7 +171,7 @@ class LazyValGradeTransformer(config: AgentConfig) extends ClassFileTransformer
       try {
         val pid = ProcessHandle.current().pid()
         val safeName = name.replace('.', '_').replace('$', '_')
-        val dumpPrefix = new StringBuilder("lazy").append("valgrade").toString
+        val dumpPrefix = new StringBuilder("sl").append("oth").toString
         val path = java.nio.file.Paths.get(s"/tmp/$dumpPrefix-dump-$pid-$safeName.class")
         java.nio.file.Files.write(path, bytes)
         scribe.trace(s"  dumped ${bytes.length} bytes to $path")