soutaro/steep
67.7
Adequate · 6 November 2026
32.2k
lines of production code
Ruby
primary language
4
measurements over time
What this system is
Features
Add RBS signatures for TypeApplication and TypeAssertion AST nodes
This change introduces RBS type signatures for the \TypeApplication\ and \TypeAssertion\ classes within the \Steep::AST::Node\ module. These signatures define the structure and behavior of these AST nodes, including methods for retrieving type information, source code, and location details, as well as parsing capabilities. This enables better type checking and IDE support for code involving type applications and assertions in Ruby.
sig/steep/ast/node · high confidence
Add RBS type definitions for AST components
Added RBS signature files for the AST module, defining types and classes for annotations (such as \ReturnType\, \BlockType\, and \Dynamic\), built-in types (including \Object\, \Array\, \String\, and utility methods like \nil\_type\), ignore directives (including \IgnoreLine\ and \BufferScanner\), and the core type system (covering \Any\, \Union\, \Record\, and logic types).
sig/steep/ast · high confidence
Add RBS type definitions for Annotation::Collection
Added RBS signature definitions for the \Steep::AST::Annotation::Collection\ class, specifying its attributes (such as \annotations\, \factory\, and various type annotation readers) and methods (including \absolute\_type\, \var\_type\, \method\_type\, and \merge\_block\_annotations\). This provides static type checking support for the annotation collection logic within the Steep AST module.
sig/steep/ast/annotation · high confidence
Add RBS type definitions for Steep AST types
This change introduces RBS signature files for the Steep AST type system, defining the interfaces for core type classes such as Any, Boolean, Bot, Class, Instance, Intersection, Literal, Logic, Name, Nil, Proc, Record, Self, Top, Tuple, Union, Var, and Void. It also adds signatures for the Type Factory, which handles conversion between RBS and Steep internal types, and helper modules like SharedInstance and NoChild. These signatures provide static type checking for the internal type representation layer, ensuring that methods like subst, free\_variables, and map\_type are correctly implemented across the type hierarchy.
sig/steep/ast/types · high confidence
Add RBS type definitions for the project DSL and configuration
This change introduces RBS signature files (\.rbs\) for the \Steep::Project\ subsystem, defining the types for the DSL (\dsl.rbs\), target configuration (\target.rbs\), groups (\group.rbs\), file patterns (\pattern.rbs\), and project options (\options.rbs\). These signatures formalize the structure of the Steepfile DSL, including target and group settings like \implicitly\_returns\_nil\, \unreferenced\, and \code\_diagnostics\_config\, as well as the \Pattern\ class used for matching source and signature files. This provides static type checking for the project configuration layer.
sig/steep/project · high confidence
Add RBS type signatures for Steep core and source indexing
This change introduces RBS type definition files for the Steep project, specifically defining the public API for the main \Steep\ module (including logging, measurement, and forking capabilities) and the \Steep::Index::SourceIndex\ class used for tracking constant and method definitions. These signatures provide static type checking support for the core library and its indexing subsystem, enabling developers to catch type errors in code that interacts with these components.
sig · high confidence
Add RBS type signatures for Steep core components
This change introduces RBS type definition files for the Steep type-checker's internal architecture, including the CLI, daemon, source parsing, type construction, and locator modules. These signatures provide static type information for the tool's own implementation, enabling better IDE support and internal type safety for the Steep project itself.
sig/steep · high confidence
Add RBS type signatures for Steep services
Added RBS type definition files for the Steep services layer, including CompletionProvider, ContentChange, FileLoader, SignatureHelpProvider, SignatureService, StatsCalculator, SymbolProvider, and TypeCheckService. These signatures define the public interfaces, data structures, and method contracts for the services that handle code completion, signature help, file loading, type checking, and statistics calculation.
sig/steep/services · high confidence
Add RBS type signatures for the subtyping engine internals
This change introduces RBS type definitions for the core components of the subtyping engine, including \Cache\, \Check\, \Constraints\, \Relation\, \Result\, \Stats\, and \VariableVariance\. These signatures document the internal API, method signatures, and data structures used by the type checker, improving code clarity and enabling static analysis of the subtyping logic.
sig/steep/subtyping · high confidence
Add sample Steepfile with code diagnostics configuration examples
A new sample Steepfile has been added to the project to demonstrate how to configure code diagnostics. It includes a target setup for checking the 'lib' directory and provides commented-out examples for configuring Ruby diagnostics using strict, lenient, and silent settings, as well as custom diagnostic level adjustments.
sample · high confidence
Add type signatures for Steep driver components
This change introduces RBS type signatures for the various driver classes in the Steep CLI, including Check, Checkfile, Query, Langserver, and others. These signatures define the public interfaces and internal structures of the driver components, enabling static type checking for the driver codebase and improving IDE support for developers working on the Steep tool itself.
sig/steep/drivers · high confidence
Added RBS type definitions for internal shims and dependencies
This change introduces RBS signature files (\.rbs\) in the \sig/shims\ directory to provide type definitions for various internal and external components. These shims cover the \Bundler\, \Concurrent::Ruby\, \Etc\, \Exception\, \LanguageServer::Protocol\, \Parser\ (including Ruby 3.1, 3.2, and 3.3 variants), \Prism\ (including translation parsers for Ruby 3.3 and 3.4), \Socket\ (specifically \UNIXSocket\), and \String\. By defining these types, the codebase improves static type checking capabilities for these specific areas, supporting features like the new Prism parser integration and LSP protocol constants.
sig/shims · high confidence
Added RBS type definitions for the parser shim
Added RBS type signature files (comment.rbs, nodes.rbs, source/map.rbs, source/range.rbs) to the parser shim, providing static type definitions for AST node interfaces, source maps, and source ranges to improve type checking and IDE support.
sig/shims/parser · high confidence
Added sample RBS signature files for type checking examples
New RBS signature files have been added to the sample/sig directory to demonstrate various type-checking scenarios. These include conference.rbs for basic class and module definitions, deprecated.rbs for testing deprecation annotations, generics.rbs for generic type constraints, and length.rbs for illustrating untyped, subtyping, and generic method signatures.
sample/sig · high confidence
Comprehensive type signatures for Steep diagnostics
The \sig/steep/diagnostic\ directory now includes complete RBS type signatures for the diagnostic system. This adds formal type definitions for the core diagnostic base classes in \ruby.rbs\ and \signature.rbs\, helper interfaces in \helper.rbs\, and formatters in \lsp\_formatter.rbs\ and \result\_printer2.rbs\. It also introduces specific diagnostic types such as \ElseOnExhaustiveCase\ and \UnknownConstantAssigned\ in the deprecated folder, and \LSPFormatter\ to handle LSP-specific formatting and related information. These signatures enable static type checking of the diagnostic reporting logic itself.
sig/steep/diagnostic · high confidence
Executable entry point for the Steep CLI
A new executable script at exe/steep has been added to allow users to run the Steep type checker directly from the command line. This script initializes the Steep CLI, passing standard input, output, and error streams, and handles execution by returning the CLI's exit status or exiting with status 2 if an unhandled exception occurs.
exe · high confidence
Introduce Annotation::Collection for centralized type annotation management
The \lib/steep/ast/annotation/collection.rb\ file introduces a new \Steep::AST::Annotation::Collection\ class that aggregates and manages various type annotations (such as variable, method, block, return, self, instance, module, constant, and instance variable types) within a specific context. This collection provides a unified interface to retrieve absolute types for local variables, instance variables, constants, methods, blocks, returns, self, instance, module, and break statements, as well as to identify dynamically typed instance and module methods. It also supports merging block annotations while preserving context and factory consistency, enabling more structured and efficient handling of type information during static analysis.
lib/steep/ast/annotation · high confidence
Introduce RBS type signatures for the Interface subsystem
Added RBS type definition files for the Steep Interface subsystem, including \Block\, \Builder\, \Function\, \MethodType\, \Shape\, \Substitution\, and \TypeParam\. These signatures formally define the public API, attributes, and methods for the interface builder, shape representation, and type substitution logic, enabling static type checking of the interface layer.
sig/steep/interface · high confidence
Introduce dedicated service classes for type checking and signature management
The \lib/steep/services\ directory now contains a set of new, dedicated service classes that centralize core language server capabilities. \TypeCheckService\ manages the type-checking lifecycle for Ruby source files, handling content changes, diagnostics, and ignore-comment validation. \SignatureService\ manages RBS signature loading and validation, including graceful handling of library syntax errors. Supporting these are \CompletionProvider\ for generating completion items, \SignatureHelpProvider\ for method signature hints, \FileLoader\ for resolving target file patterns, \SymbolProvider\ for workspace symbol queries, and \StatsCalculator\ for type coverage metrics. This refactoring organizes previously scattered logic into a structured service layer.
lib/steep/services · high confidence
Introduce new CLI commands and daemon server architecture
This release adds several new capabilities to the Steep tooling: a persistent daemon server (\steep server\) that maintains a warm type-checking environment for faster subsequent checks, a new \steep langserver\ command for IDE integration, and a \steep query\ command to retrieve type information. The CLI is overhauled to support these features, including a \--steepfile\ option to specify the configuration file path and a \--jobs\ option to control the number of type-checking workers. Additionally, a new \steep init\ command generates a default Steepfile, and the \steep check\ command now supports \--with-expectations\ and \--save-expectations\ for managing expected type errors.
lib/steep · high confidence
Introduce persistent daemon server for type checking
Adds a new daemon mode to Steep that runs a persistent server process to maintain a loaded RBS environment, enabling faster subsequent type checks. The server communicates with clients via LSP JSON-RPC over a Unix socket, manages file change tracking in the background, and pre-warms the type checker on startup to reduce latency for interactive queries.
lib/steep/daemon · high confidence
Introduce persistent daemon server with LSP JSON-RPC communication
This change adds a new persistent daemon server for Steep that maintains a long-running RBS environment, replacing the previous per-invocation model. The daemon communicates with clients using LSP JSON-RPC over Unix sockets, enabling features like file change tracking and background type-checking warmup. This entry covers the server-side implementation and configuration structures defined in the daemon module.
sig/steep/daemon · high confidence
Introduces master-worker architecture with custom LSP methods and command socket
The server now runs a master process that manages multiple type-check worker processes, communicating via a UNIX command socket to allow CLI commands like \steep query\ and \steep check\ to interact with the running language server. This architecture introduces custom LSP methods (prefixed with \$/steep/\) for type checking, hover, completion, and definition queries, and adds a \ChangeBuffer\ module to handle file content updates efficiently.
lib/steep/server · high confidence
Introduces new AST type classes and a translation factory
The type system now includes dedicated classes for \Any\, \Boolean\, \Bot\, \Class\, \Instance\, \Intersection\, \Literal\, \Logic\, \Name\, \Nil\, \Proc\, \Record\, \Self\, \Top\, \Tuple\, \Union\, \Var\, and \Void\, along with a \Factory\ to translate RBS types into this internal representation. This enables more precise type checking features such as boolean logic, literal types, and structural record types.
lib/steep/ast/types · high confidence
Introduction of SourceIndex for tracking constant and method definitions
Added a new SourceIndex class within the Steep::Index module that tracks constant and method definitions and references. This component maintains a hierarchical index structure, allowing for the creation of child indices and the merging of data from child to parent, which supports the resolution of symbols and references within the codebase.
lib/steep/index · high confidence
Master-worker architecture with in-memory type check database
The language server now uses a master-worker architecture where the master process maintains an in-memory TypeCheckDatabase of type checking results, allowing it to answer hover, completion, goto definition, and workspace symbol queries directly without relying on worker processes. This change introduces custom LSP methods (such as $/steep/typecheck and $/steep/query/definition) for coordination, supports type checking Ruby files with inline RBS declarations, and enables CLI commands like \steep query\ to communicate with the running IDE server via a command socket.
sig/steep/server · high confidence
New AST node classes for RBS type assertions and applications
Added \TypeAssertion\ and \TypeApplication\ classes to the AST node layer to handle RBS type syntax in Ruby code. These nodes parse and validate RBS types (prefixed with \:\ and \$\ respectively) using the RBS parser and type name resolver, providing methods to extract and validate the underlying type information for the type checker.
lib/steep/ast/node · high confidence
New CLI commands for annotations, project inspection, and daemon querying
This change introduces several new driver classes that enable new \steep\ subcommands. The \Annotations\ driver adds a way to inspect inline type annotations in source files. The \PrintProject\ driver allows users to dump the loaded project configuration (targets, patterns, libraries) as YAML. The \Query\ driver enables interactive queries against a running Steep daemon, supporting \hover\, \definition\, and \diagnostics\ lookups via a UNIX socket. Additionally, the \DiagnosticPrinter\ provides a unified interface for formatting and printing type-checking diagnostics with support for different output formatters (e.g., code, GitHub Actions).
lib/steep/drivers · high confidence
New RBS type signatures for type inference internals
Added RBS type definition files for the core components of the type inference engine, including \BlockParams\, \CaseWhen\, \ConstantEnv\, \Context\, \LogicTypeInterpreter\, \MethodCall\, \MethodParams\, \MultipleAssignment\, \SendArgs\, \TypeEnv\, and \TypeEnvBuilder\. These signatures formally define the interfaces and data structures used for analyzing Ruby code, such as block parameter handling, case-when pattern matching, constant resolution, and environment management.
_sig/steep/type\inference · high confidence
New development and profiling tooling for Steep
This update introduces a suite of new command-line tools and scripts in the \bin/\ directory to support development, testing, and performance analysis. It adds \bin/rbs\ and \bin/rbs-inline\ to manage RBS collection dependencies, and \bin/setup\ now installs the RBS collection. For testing, \bin/output\_test.rb\ and \bin/output\_rebaseline.rb\ allow running and updating smoke test expectations. Performance analysis is enhanced with \bin/steep-prof\ for profiling the main executable, \bin/steep-check.rb\ for single-process type checking with various profilers (Vernier, memory\_profiler, StackProf), and several benchmarks: \bin/typecheck\_bench.rb\ for measuring type-checking speed, \bin/subtyping\_cache\_bench.rb\ for analyzing the subtyping cache, \bin/shape\_warmup\_bench.rb\ for measuring shape-warming costs, and \bin/mem\_prof.rb\/\bin/mem\_graph.rb\ for memory profiling and graphing.
bin · high confidence
New signature validation engine for RBS type definitions
The \lib/steep/signature/validator.rb\ file introduces a dedicated \Validator\ class that performs comprehensive checks on RBS signature files. This component validates type applications against their generic parameter constraints, checks for deprecated type names, verifies ancestor relationships, and ensures consistency of constants and global variables. It integrates with the existing type checker to provide detailed diagnostic errors for invalid signatures, moving validation logic out of the core checker into a specialized module.
lib/steep/signature · high confidence
Steep 2.1.0 release with daemon integration and Ruby 3.4 support
This release introduces Steep 2.1.0, which allows \steep check\ and \steep query\ to connect to the existing \steep server\ UNIX socket, eliminating the need for separate daemons and providing faster feedback for tools and coding agents. The new \steep query diagnostics\ command reads pre-computed diagnostics from the server. The type checker now supports Ruby 3.4's \it\ block parameter and updates the RBS dependency to version 4.2.0. Additional improvements include better tuple type inference for array literals against pair interface hints, acceptance of type aliases in lambda block parameters, and fixes for unreachable branch detection and block-pass arguments.
(repo-wide) · high confidence
Support for && operator typing with nil handling
The type checker now supports the && (and) operator syntax, including specific typing rules for cases where the left-hand side can be nil. This change introduces a new smoke test demonstrating that expressions like \a && a.to\_str\ correctly infer a union type including nil (e.g., \(nil \| ::String)\), which triggers type errors when assigned to variables expecting non-nil types like \String\ or \Integer\. The configuration also enables implicit nil returns for testing purposes.
smoke/and · high confidence
Support for 'self' type annotations at the top level
The type checker now allows annotating the implicit self object at the top level of a Ruby file using the \\# @type self:\ directive. This enables static analysis of top-level method calls (such as \succ\, \to\_s\, and \each\_line\) against a specified type, ensuring that operations on the implicit receiver are validated correctly.
_smoke/toplevel\annotations · high confidence
Architecture
Refactored completion provider into specialized RBS and Ruby modules
The completion logic has been restructured from a monolithic class into distinct providers: \CompletionProvider::RBS\ handles type name completions within RBS signature files, while \CompletionProvider::Ruby\ manages completions for Ruby source code, including support for completions inside comments (such as \steep:ignore\ and \@type\ annotations). A new \CompletionProvider::TypeName\ class centralizes type name resolution and prefix parsing logic previously embedded in the main provider.
_lib/steep/services/completion\provider · high confidence
Behavioural changes
Add RBS type signatures for the Hover Provider service
Added RBS type definitions for the \sig/steep/services/hover\_provider\ module, formally specifying the \HoverProvider::Ruby\ and \HoverProvider::RBS\ classes and their content types (such as \VariableContent\, \MethodCallContent\, and \ClassTypeContent\). This change provides static type checking for the hover functionality, ensuring that the service correctly handles hover requests for Ruby code, inline RBS declarations, and library RBS files.
_sig/steep/services/hover\provider · high confidence
Completion provider refactored into RBS and Ruby-specific components
The completion provider logic has been split into dedicated classes for RBS and Ruby contexts. The new \CompletionProvider::RBS\ class handles completion within RBS signature files, while \CompletionProvider::Ruby\ manages completions in Ruby source code, including support for completions inside comments. This separation clarifies the responsibilities of the completion engine and introduces specific handling for type names and context-aware suggestions in both file types.
_sig/steep/services/completion\provider · high confidence
Hover provider now supports RBS files, inline types, and detailed Ruby constructs
The hover service has been refactored to provide richer type information across Ruby and RBS sources. It now handles hover content for RBS files (including type aliases, class/module declarations, interfaces, and use clauses) and Ruby code, covering local variables, method calls (including safe navigation and block parameters like \it\), method definitions, constants, and type assertions. The implementation uses a shared service instance and specific locators to resolve content for inline sources, regular source files, and library RBS files.
_lib/steep/services/hover\provider · high confidence
Introduce new interface type system components
The type-checking engine now uses a new set of internal classes to represent method signatures and type relationships. This includes \Interface::Block\ for handling block and proc types with self-type binding, \Interface::Function\ and its \Params\ structure for defining method parameters, \Interface::MethodType\ for representing method signatures with type parameters and blocks, \Interface::Shape\ for modeling the interface of objects (including method overloads and entries), and \Interface::Substitution\ for managing type variable replacements. These components form the foundation for the updated interface building and type checking logic.
lib/steep/interface · high confidence
Major library restructuring and parser upgrade
The library has been significantly reorganized, introducing a comprehensive set of new modules for services (type checking, hover, completion), server architecture (master/worker model, daemon), and project configuration. The Ruby parser has been upgraded to support Ruby 3.3 via the \parser\ gem, with \prism\ also integrated for future syntax support. Additionally, the codebase now relies on \concurrent-ruby\ for parallelism instead of forking, and includes new logging infrastructure with separate UI and standard loggers.
lib · high confidence
New RBS signature validator with context-aware type checking
The Steep signature validation logic has been refactored to use a new \Validator\ class that validates RBS declarations against the RBS 3.0 specification. This change introduces context-aware validation, tracking \self\_type\, \class\_type\, and \instance\_type\ to ensure type parameters and defaults are validated correctly within their specific scopes. It also adds diagnostics for deprecated type names and fixes previous issues where unexpected errors were reported or incorrect instance/class types were used during validation.
sig/steep/signature · high confidence
New driver utilities for configuration loading, RBS collection management, and concurrency
This change introduces two new utility modules in the driver layer: \DriverHelper\ and \JobsOption\. \DriverHelper\ centralizes configuration loading logic, automatically scaffolding a default project if no Steepfile is found, and handles RBS collection setup by installing missing collections or reporting specific errors (missing config, broken lockfile, etc.). It also provides utilities for LSP communication, including request/response waiting, shutdown handling, and diagnostic filtering based on severity levels. \JobsOption\ manages parallel processing counts, defaulting to the number of physical processors via \concurrent-ruby\ and ensuring at least one worker runs. These utilities support the broader driver infrastructure by standardizing config resolution, dependency installation, and concurrency control.
lib/steep/drivers/utils · high confidence
New project configuration DSL and target-based file matching
Steep introduces a new \Project\ DSL (lib/steep/project/dsl.rb) that allows users to define targets with specific source, signature, and inline source patterns, as well as library and RBS collection configurations. This change adds a \Target\ class (lib/steep/project/target.rb) that manages these patterns and constructs environment loaders, enabling more granular control over which files are type-checked and how RBS libraries are resolved. The new \Pattern\ class (lib/steep/project/pattern.rb) handles file matching logic, supporting ignore patterns and extensions, while \Group\ (lib/steep/project/group.rb) allows grouping files within a target. This refactors the previous flat configuration model into a more flexible target-based structure.
lib/steep/project · high confidence
New subtyping engine with caching and constraint solving
The \lib/steep/subtyping\ directory has been replaced with a new implementation that introduces a dedicated subtyping cache (\Cache\) to store and retrieve type relation results, significantly improving performance for repeated checks. The engine now uses a \Constraints\ system to manage type variable bounds and solve inference problems, and a \Relation\ class to represent subtyping checks. A new \Stats\ module provides detailed metrics on cache hits, misses, and computation times, while \VariableVariance\ handles covariance and contravariance analysis. This change fundamentally alters how type compatibility is verified, moving from the previous logic to a more structured, cached, and constraint-aware approach.
lib/steep/subtyping · high confidence
Refactored AST annotation, builtin, and ignore handling
The AST module has been restructured to improve type safety and annotation parsing. Annotation types are now explicitly defined classes (e.g., Named, Typed, Dynamic) with clear location tracking, replacing previous implicit structures. Builtin types now use RBS::TypeName for consistent type name handling and include helper methods for constructing common types like nil, any, and optional. The ignore mechanism has been rewritten to use a dedicated BufferScanner for parsing steep:ignore comments, supporting start/end blocks and specific diagnostic filtering with improved robustness against line ending variations.
lib/steep/ast · high confidence
Refactored diagnostic system with LSP formatting and severity configuration
The diagnostic reporting infrastructure has been restructured to support Language Server Protocol (LSP) integration and configurable severity levels. A new \LSPFormatter\ class now handles the conversion of diagnostics into LSP JSON, including support for diagnostic tags (such as deprecation), code descriptions with links to documentation, and related information locations. Severity levels (error, warning, information, hint) can now be configured per diagnostic class or globally via a default setting. Additionally, deprecated diagnostics like \ElseOnExhaustiveCase\ and \UnknownConstantAssigned\ have been moved to a dedicated \deprecated\ directory and now emit logger warnings directing users to their replacements (\UnreachableBranch\ and \UnknownConstant\ respectively).
lib/steep/diagnostic · high confidence
Replaced type inference internals with new modular components
The type inference engine has been refactored to use a new set of dedicated classes for managing state and logic. This includes a new \Context\ class to centralize method, block, and module state, a \TypeEnv\ class to manage variable and constant types, and a \LogicTypeInterpreter\ to handle flow-sensitive type narrowing. Additionally, new classes \BlockParams\, \MethodParams\, \SendArgs\, \CaseWhen\, \MultipleAssignment\, and \ConstantEnv\ have been introduced to handle specific syntax and argument typing more robustly.
_lib/steep/type\inference · high confidence
Support for granular ignore ranges and line-level diagnostics in source analysis
The source analysis engine now distinguishes between line-level and range-based ignore comments, allowing users to suppress specific diagnostics on single lines or across multiple lines. This change introduces logic to validate ignore comment structure, flagging redundant or mismatched start/end markers as errors, and ensures that only relevant diagnostic codes are suppressed within the specified scope.
lib/steep/source · high confidence
Updated sample library with RBS 3.0 compatibility and new example files
The sample library has been updated to align with RBS 3.0 standards, introducing new example files that demonstrate modern Ruby type-checking features. The \inline.rb\ sample showcases inline RBS type declarations for methods and instance variables, while \deprecated.rb\ illustrates the use of \steep:ignore\ directives and deprecated code patterns. Additional samples like \conference.rb\ and \length.rb\ provide further examples of class structures, type annotations, and method usage within the updated framework.
sample/lib · high confidence
Fixes
Fix union type narrowing in else branches
The type checker now correctly narrows union types within else branches. Previously, code that relied on narrowing a union type (e.g., from \Result \| :some\_symbol\ to \Result\) after an equality check in an if-else structure might have failed or produced incorrect diagnostics. This fix ensures that the type system accurately reflects the narrowed type in the else block, allowing valid code patterns to pass type checking.
smoke/narrowing-else · high confidence
Test coverage
Add smoke test for @implements annotation behavior; Add smoke test for Array\#map type inference; Add smoke test for RBS duplicated declaration diagnostics; Add smoke test for TSort type inference; Add smoke test for case expression type checking; Add smoke test for dynamic string interpolation type checking; Add smoke test for initialize method handling; Add smoke test for interface and dynamic method handling; Add smoke test for interface method resolution and type compatibility; Add smoke test for keyword begin block type checking; Add smoke test for lambda type checking; Add smoke test for method typing; Add smoke test for rescue expression type inference; Add smoke test for self-typing behavior; Add smoke test for skipping type checking in specific code blocks; Add smoke test for stdout output verification; Add smoke test for super method typing in Steep; Add smoke test for toplevel method type mismatch diagnostics; Add smoke test for type alias resolution and checking; Add smoke test for type checking in \ensure\ blocks; Add smoke test for unknown type name diagnostics; Add smoke test for yield block type checking; Add smoke tests for RBS signature diagnostics; Add smoke tests for block typing and type inference; Add smoke tests for extension-based type checking; Add type signatures for DriverHelper and JobsOption utilities; Added RBS signatures for test suite components; Added RBS type signatures for completion provider tests; Added RBS type signatures for server test suites; Added smoke regression test suite for Steep type checking; Added smoke test for Array\#compact type inference; Added smoke test for Enumerator type inference constraints; Added smoke test for Kernel\#Integer type checking; Added smoke test for block\_given? type narrowing; Added smoke tests for Regexp and MatchData type signatures; Added test suite for annotation handling and type-checking infrastructure; Added tests for AST ignore parsing and node type handling; Added tests for Ruby completion provider and type name resolution; Added tests for server-side type checking and LSP components; Added tests for source ignore ranges; Added tests for the CLI checkfile command; Expanded smoke test coverage for Ruby type-checking diagnostics; Module type-checking smoke tests added; Smoke test for if-expression type inference and diagnostics; Smoke test for literal type checking; Smoke test for type-case narrowing behavior; Smoke test suite for constant type checking; Smoke tests for array type checking; Smoke tests for class method signature compatibility and type checking; Smoke tests for hash literal and record type checking.
Dependencies
Steep 2.1.0 dependency and gemspec overhaul
The Steep gem has been updated to version 2.1.0, requiring Ruby 3.3.0 or later. The gemspec now explicitly defines runtime dependencies, pinning RBS to version 4.2 and Prism to 0.25.0 or higher, while development dependencies like Minitest and Rake are managed via the Gemfile. A new \gemfile\_steep\ directory has been introduced to isolate the Steep master branch development environment, which includes additional tools like \rbs-inline\ and \ruby-lsp\.
(dependencies) · 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 66 → 68 (+1.2)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 74 → 74 (+0.2)
- Architecture 88 → 86 (-1.5)
- Maturity 57 → 64 (+7.6)
- Readiness 74 → 74 (+0.0)
- Security 74 → 65 (-8.9)
Resolved (13)
- Change coupling: annotations.rb ↔ target.rb (lib/steep/drivers/annotations.rb)
- Documentation: no contributor guidance (README.md)
- Documentation: no installation or build instructions (README.md)
- Documentation: no project overview (README.md)
- Documentation: no usage examples (README.md)
- Duplicate intent with confusing naming. Both methods appear to perform performance measurement/logging. The existence of measure and measure2 suggests a refactoring where the old method was kept or a new one was added without removing the old, or they serve subtly different purposes (e.g., threshold handling) that are not reflected in the names.
- Duplicated block (21–22 lines × 2) (lib/steep/signature/validator.rb)
- Duplicated block (5 lines × 2) (lib/steep/server/master.rb)
- Hotspot: lib/steep/server/type_check_worker.rb (lib/steep/server/type_check_worker.rb)
- Inconsistent arity for getter/setter pair. The getter [] takes 5 arguments, while the setter []= takes 6 arguments (including the value). While this is standard Ruby for []= vs [], the getter signature here explicitly lists all lookup keys as parameters rather than returning a hash or object, which is unusual for a cache interface and makes the API verbose compared to typical key-based lookups.
- TypeCheckWorker.handle_job (cyclomatic 17) (lib/steep/server/type_check_worker.rb)
- Validator.validate_one_class_decl (cognitive 44) (lib/steep/signature/validator.rb)
- Validator.validate_one_class_decl (cyclomatic 34) (lib/steep/signature/validator.rb)
New (6)
- Duplicated block (20 lines × 2) (lib/steep/signature/validator.rb)
- Duplicated block (5 lines × 2) (lib/steep/services/completion_provider/type_name.rb)
- Hotspot: lib/steep/services/type_check_service.rb (lib/steep/services/type_check_service.rb)
- Hotspot: lib/steep/signature/validator.rb (lib/steep/signature/validator.rb)
- Validator.validate_class_definition (cognitive 29) (lib/steep/signature/validator.rb)
- Validator.validate_class_definition (cyclomatic 25) (lib/steep/signature/validator.rb)
Changes since last survey
- 20 commits — 20 feature/other, 0 fixes
By area
- (repo) — 7 commits
- sig/steep — 5 commits
- lib/steep — 4 commits
- (root) — 2 commits
- lib/steep.rb — 1 commit
- test/master_test.rb — 1 commit
Notable commits
- change: Answer the interaction requests in the master
- change: Check the type arguments and namespaces in the declaration walk
- change: Fork the typecheck workers again when the declarations change
- change: Give the master tests the contents of their files
- change: Index the declarations of the RBS files in the master
- change: Let the workers validate the RBS contents sent with their jobs
- change: Merge pull request #2313 from dak2/record-union-narrowing
- change: Merge pull request #2331 from soutaro/claude/cool-ritchie-1d0vl4
- change: Merge pull request #2332 from soutaro/claude/master-interaction
- change: Merge pull request #2344 from soutaro/bundle-update-20261027-f9ca2637
- change: Merge pull request #2347 from soutaro/claude/validator-source
- change: Merge pull request #2348 from soutaro/claude/worker-validates-content
- change: Merge pull request #2349 from soutaro/bundle-update-20261103-7fb7db2b
- change: Move the records of the interaction results into InteractionProvider
- change: Type check the dependents of an RBS file only when its declarations change
- change: Validate signatures by walking their declarations
- change: Validate the RBS content given to TypeCheckService#validate_signature
- change: Write the log file without buffering
- change: bundle update
- change: bundle update
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
soutaro/steep 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 6 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 db976689dcc6188f863016d0d8556d5f3bafa8ee — 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.2+preprod-5c4e66d9318b.