Skip to content
CAI
Software that uses CAICheck a score

guardian/typerighter

37.8

Weak · 6 November 2026

11.3k

lines of production code

Scala

with TypeScript

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Collins Dictionary integration for English spelling checks

The checker now includes a new Collins Dictionary service for English, allowing users to benefit from its specific lexical coverage. This change introduces the \CollinsEnglish\ language provider and the \MorfologikCollinsSpellerRule\ within the \services.collins\ package, which integrates a Morfologik-based spelling rule into the LanguageTool pipeline. To support this, new Scala-based dictionary building utilities (\DictionaryBuilder\, \SpellDictionaryBuilder\) have been added to compile the Collins word list into the required binary format, and the existing Java collins-related services have been organized into this dedicated sub-directory.

apps/checker/app/services/collins · high confidence

Add MatcherResponse model for validator output

A new \MatcherResponse\ case class has been added to the model layer to represent the output of the validation process. This data structure includes text blocks, category IDs, and rule matches, and provides JSON serialization support for sending this response to clients.

apps/checker/app/model · high confidence

Added UK English dictionary resources for spellchecking

Added a new UK English (en\_GB) dictionary resource to the spellchecker configuration, including a wordlist with word frequencies and a configuration file defining spelling rules such as diacritic handling and replacement pairs. This enables the spellchecker to validate words against this specific dictionary and provide suggestions based on word frequency.

apps/checker/conf/resources · high confidence

Added pre-commit hook for Scala code formatting

A new pre-commit hook has been added to automatically check Scala code formatting using scalafmt before commits are finalized. The hook first attempts to use the scalafmt CLI for performance; if that is not available, it falls back to running \sbt scalafmtAll\. It respects the project's \.scalafmt.conf\ configuration and excludes the \target\ directory, ensuring consistent code style without requiring manual formatting steps.

script/hooks · high confidence

Initial CDK project setup for Typerighter infrastructure

The CDK directory has been initialized with the necessary configuration files to manage Typerighter's AWS infrastructure. This includes a \tsconfig.json\ configured for TypeScript compilation, a \cdk.json\ for CDK toolkit execution, and Jest configuration files (\jest.config.js\, \jest.setup.js\) to support snapshot testing of the CDK stacks. A \.gitignore\ file has also been added to exclude build artifacts and node modules.

cdk · high confidence

Initial configuration and routing for the Rule Manager service

The Rule Manager service is now configured with a Play Framework application loader, PostgreSQL database connection settings (including HikariCP pool tuning), and ScalikeJDBC logging. The service exposes a comprehensive set of REST API endpoints under /api/rules and /api/tags for managing rules (listing, creating, updating, publishing, archiving, CSV import, batch operations) and tags, along with health checks and OAuth callbacks. Logging is set up via Logback with JSON encoding for ELK compatibility, and the application includes client-side routing support for the frontend assets.

apps/rule-manager/conf · high confidence

Initial database layer and rule model definitions

This change introduces the foundational database connection handling and the core data model for rules within the rule manager. It adds a new DB class to manage PostgreSQL connections and health checks, and defines the DbRule trait and object to specify the schema columns and common properties for rule entities, including fields like ruleType, pattern, externalId, and revisionId.

apps/rule-manager/app/db · high confidence

Initial project scaffolding and configuration for Typerighter

This change introduces the foundational configuration files and documentation for the Typerighter service, establishing the development environment and deployment structure. It sets the Java runtime to version 17 (via .java-version and .tool-versions) and Node.js to 24.13.1 (via .nvmrc), while enforcing strict engine matching in .npmrc. The project adopts Scalafmt 3.7.17 for Scala code formatting and configures Scala Steward to group patch updates. Operational tooling is added, including a docker-compose.yml for local PostgreSQL and LocalStack S3 instances, a .prout.json for deployment health monitoring, and a riff-raff.yaml defining deployment stacks for the checker and rule-manager services. The repository is also initialized with standard legal and informational files (LICENSE.md, NOTICE.md, README.md, vision.md) and updated .gitignore rules.

(repo-wide) · high confidence

Initial release of the Rule Manager application

The rule-manager service is now available, providing endpoints to manage rules, tags, and dictionary resources. Users can interact with the system via the RulesController (handling rule creation, listing, and testing) and the TagsController (handling tag CRUD operations). The application supports local development via LocalStack S3 and production deployments using standard AWS S3, with database migrations handled automatically through Play Evolutions.

apps/rule-manager/app · high confidence

Introduce Rule Manager API endpoints for rules and tags

The rule manager application now exposes a comprehensive set of API endpoints for managing matcher rules and tags. RulesController provides endpoints to list, retrieve, create, update, and batch-update draft rules, as well as publish them with permission checks. It also includes endpoints to refresh rules from Google Sheets and refresh dictionary rules from S3. TagsController allows listing tags with associated rule counts, retrieving individual tags, creating, updating, and deleting tags. All rule modification and tag management endpoints require the 'manage\_rules' permission, while read-only operations and tag listing are accessible to authenticated users. A new HomeController provides the main application index, health check, and OAuth callback.

apps/rule-manager/app/controllers · high confidence

Introduce Rule Manager client application with rule editing, batch operations, and tag management

The rule-manager client application has been added to the codebase, providing a comprehensive interface for managing rules. Users can now create, edit, and publish rules with automatic debounced saving, view detailed diffs between live and draft states, and manage rule metadata including categories and tags. The interface supports batch editing of multiple rules simultaneously, allows for the creation, editing, and deletion of tags, and includes a feature switch system for toggling specific capabilities like destructive reloads. The UI is styled with Guardian-specific fonts and themes, and includes a 404 page and periodic data refresh for rule status updates.

apps/rule-manager/client/src · high confidence

Introduce dictionary rule support and rule testing capabilities

The rule manager now supports a new 'dictionary' rule type, ingesting word lists from S3 via the new DictionaryResource and allowing users to specify words to exclude from publishing. Additionally, a new RuleTesting service enables testing rules against live content from the Content API, paginating through results and streaming matches back to the user.

apps/rule-manager/app/service · high confidence

Introduce draft/live rule separation and batch editing capabilities

The rule management system now distinguishes between draft and live rule states, storing them in separate \rules\_draft\ and \rules\_live\ tables to support a proper publication workflow. This change introduces batch editing for rules, allowing administrators to update categories and tags for multiple rules simultaneously via the \BatchUpdateRuleForm\. Additionally, the system now supports a new 'dictionary' rule type, which can be ingested and published, and includes logic to handle rule priorities and active states during publication.

repository · high confidence

Introduce new API and UI controllers for the checker service

The checker service now exposes dedicated controllers for its core functionality. The new ApiController handles API requests, including a standard check endpoint, a streaming check endpoint (using json-seq), and a new HMAC-authenticated endpoint to check a single rule. A CapiProxyController provides endpoints to search Content API content, tags, and sections. The HomeController manages the main index page, health checks (now including rule count validation and git commit ID), and OAuth callbacks, while the RulesController serves the UI for managing matcher rules.

apps/checker/app/controllers · high confidence

Introduce utility modules for dictionary parsing, permissions, and configuration

This change adds several new utility components to the rule manager application. It introduces a Dictionary parser (Dictionary.scala) capable of streaming and extracting word lists and definitions from large Collins dictionary XML files, supporting features like lemmatization and subject extraction. A new Permissions module (Permissions.scala) is added to handle user permission checks against a remote store and serialize user/permission data to JSON for the frontend. Configuration is centralized via a new RuleManagerConfig class that extends CommonConfig to expose database, Google credentials, and checker service URLs. Additionally, helper utilities are provided for form error serialization (FormHelpers.scala), local AWS S3 client setup for development (LocalStack.scala), string case conversion (StringHelpers.scala), and standard error types (Errors.scala).

apps/rule-manager/app/utils · high confidence

Introduces abstract PandaAuthController for shared authentication logic

The \PandaAuthController\ abstract class has been added to centralize authentication configuration and validation for Typerighter controllers. It integrates PanDomain and HMAC authentication via \AuthActions\ and \HMACAuthActions\, handling user validation against Guardian accounts and defining OAuth callback URLs and secret keys based on the application's common configuration. This change provides a reusable base for controllers requiring this specific authentication flow.

apps/common-lib/src/main/scala/com/gu/typerighter/controllers · high confidence

New dictionary and regex matchers with entity-aware filtering

The matcher pool now includes a DictionaryMatcher that uses the Collins dictionary via LanguageTool, a LanguageToolMatcher for pattern-based rules, and a RegexMatcher for regular expression checks. The DictionaryMatcher specifically integrates with a Named Entity Recognition (NER) service to exclude matches that fall within named entities, reducing false positives for proper nouns. It also forces the Morfologik dictionary cache to invalidate immediately when rules change, ensuring updates are reflected without waiting for the default 10-minute expiration. Dictionary matches are assigned a unique groupKey based on the matched text to allow proper client-side grouping, and all new matchers implement the standard Matcher interface for integration into the checker.

apps/checker/app/matchers · high confidence

New utility classes for configuration, metrics, and performance timing

The checker application now includes a set of new utility components in the \utils\ package. \CheckerConfig\ centralizes application settings, including NER API credentials and spreadsheet IDs. \CloudWatchClient\ enables the publication of custom metrics (such as rules ingested and matcher job duration) to AWS CloudWatch. \Matcher\ and \MatcherCompanion\ traits define the interface for rule matching logic, while \RuleMatchHelpers\ provides utilities for filtering overlapping rule matches. Additionally, the \Timer\ object offers synchronous and asynchronous timing functions that log performance data and warn when operations exceed a configurable slow-log threshold.

apps/checker/app/utils · high confidence

Removals

Removal of legacy ApiController

The ApiController, which previously handled the root index and a form-encoded check endpoint for the LanguageTool service, has been removed from the application. This deletion indicates that the legacy API surface is no longer supported or has been superseded by other controllers.

app/controllers · high confidence

Removal of legacy LanguageTool service wrapper

The \LanguageTool\ service wrapper in \app/services\ has been removed. This change eliminates the previous implementation that instantiated \JLanguageTool\ with a hardcoded \en-GB\ language code, a fixed-size result cache, and a basic text-checking method, indicating a shift in how language processing is handled within the application.

app/services · high confidence

Architecture

Consolidate Typerighter infrastructure into a single CDK stack

The previously separate rule-manager and rule-manager-db stacks have been removed and consolidated into a new, unified Typerighter stack in cdk/lib. This change introduces a single entry point that provisions both the checker and rule-manager applications, their associated CloudFront distributions, DNS records, and the underlying RDS database, simplifying the deployment structure for the Typerighter service.

cdk/lib · high confidence

Behavioural changes

Added pre-flight checks for AWS credentials, Java, and Node versions

The project now includes a new \script/lib/check\ entry point that explicitly sources and runs validation scripts for AWS credentials, Java version, and Node version before proceeding. Users will now receive immediate, clear error messages if their environment is misconfigured—such as expired or missing AWS credentials for the 'composer' profile, or a mismatch between the installed and required versions of Java or Node—preventing downstream failures during development or deployment.

script/lib · high confidence

Checker app restructured with new configuration and AWS SDK v2 integration

The checker application has been refactored to use the AWS SDK v2 and a new centralized configuration system. The app now initializes via a dedicated AppLoader and AppComponents, supporting both production AWS environments and local development via LocalStack S3 with path-style access enabled. Configuration values such as region, identity, and credentials are now passed explicitly, and the app integrates with the Typerighter bucket for rule management, NER service for entity recognition, and CloudWatch for monitoring. The UI assets have been updated with new styles for the sidebar, controls, and loading indicators.

apps/checker/app · high confidence

Checker service configuration and routing setup

The checker service now includes its own configuration files, introducing a new application.conf that sets a Content Security Policy, allows larger HTTP payloads (4MB buffer), and configures the matcher-pool dispatcher. Routing is defined for API endpoints including /check, /checkStream, and /checkSingle, alongside OAuth and health check paths. Logging has been updated to use a Logstash encoder for stdout and changed the root log level to INFO, with logs directed to a configurable home directory.

apps/checker/conf · high confidence

Consolidated CDK entry point for Typerighter stacks

The CDK application entry point in cdk/bin/index.ts has been rewritten to instantiate the Typerighter stack directly for both CODE and PROD environments. This change replaces the previous multi-stack structure (which included separate rule-manager and rule-manager-db stacks) with a single consolidated stack configuration, setting instance counts to 1 for CODE and 3 for PROD, and assigning specific domain suffixes for each stage.

cdk/bin · high confidence

Database schema evolution for rule management

The rule-manager database schema has been evolved through 17 migrations to support a draft-and-live rule model. Key changes include splitting rules into 'rules\_draft' and 'rules\_live' tables, introducing 'external\_id' as a required unique identifier, and adding support for tags via new 'tags' and join tables. The schema now tracks revision history, enforces active rule ordering, supports archiving, and includes optimized GIN indexes for full-text search and pattern matching.

apps/rule-manager/conf/evolutions · high confidence

Introduce RuleMatch model with replacement behavior and context support

The Typewriter model layer now includes a new \RuleMatch\ case class and serialization logic that enables richer error reporting. When a rule provides one or more suggestions, the system automatically triggers a 'replacement' behavior in the client by exposing the first suggestion as the primary replacement option. Additionally, the model now captures surrounding text context (preceding and subsequent characters) and generates a match snippet for better visibility. The serialization logic ensures that a \groupKey\ is always present in the output, defaulting to the rule ID if not explicitly set, and the model supports mapping matches through skipped text ranges to adjust positions accurately.

apps/common-lib/src/main/scala/com/gu/typerighter/model · high confidence

Introduce entity recognition to exclude named entities from dictionary matches

The checker now uses an external NER (Named Entity Recognition) service to identify entities such as persons, organizations, and locations. These identified entities are excluded from dictionary-based spelling checks, preventing false positives on proper nouns. This change also introduces a streaming API for the matcher pool, allowing clients to receive check results incrementally with progress percentages, and adds support for checking single rules independently.

apps/checker/app/services · high confidence

Introduce shared Typerighter library for configuration, authentication, and API clients

This change introduces a new common library (apps/common-lib) that consolidates shared infrastructure for the Typerighter services. It provides a unified AppSetup and CommonConfig for managing AWS credentials, SSM configuration, and PanDomain authentication settings. The library also includes a ContentClient for interacting with the Guardian Content API, an HMACClient for generating authentication headers, and utilities for JSON serialization (including newline-delimited JSON) and safe XML parsing, standardizing how these services handle configuration and external API calls.

apps/common-lib/src/main/scala/com/gu/typerighter/lib · high confidence

Introduces structured form validation and pagination support for rule management

The rule-manager now uses dedicated form models to validate and construct rule data, replacing previous basic validation. This includes specific forms for Regex rules (with regex syntax checking), XML rules (with XML parsing validation), LanguageTool core rules, and Dictionary rules, ensuring users receive clear error messages for invalid inputs. Additionally, a new PaginatedResponse model has been added to support paginated queries for the main rules list, improving performance and usability when managing large sets of rules.

apps/rule-manager/app/model · high confidence

LocalStack setup script initializes S3 buckets and uploads dictionary assets

The localstack environment now includes an init-aws.sh script that automatically creates the typerighter-app-local S3 bucket and populates it with essential dictionary files (collins-dictionary.xml, collins-lemmatised-list.xml, and words-to-not-publish.json) copied from the /etc/gu/typerighter/ directory, ensuring these resources are available for local development.

localstack · high confidence

Migrate rules storage to newline-delimited JSON with legacy fallback

The system now stores checker rules in S3 as newline-delimited JSON (one rule per line) instead of a single JSON array, and retrieves them by parsing each line individually. To ensure continuity during the transition, the new storage implementation automatically falls back to reading the legacy single-file JSON format if the new arteact is missing or unreadable. This change is implemented in the new BucketRuleResource class, which handles both writing the new format and reading from either the new or legacy keys.

apps/common-lib/src/main/scala/com/gu/typerighter/rules · high confidence

New Typerighter UI with breadcrumb navigation and telemetry

The checker application now features a new user interface built on a shared layout template. This update introduces a breadcrumb navigation component for better context awareness and integrates pixel-based telemetry tracking to monitor page views. The main layout includes a navigation bar with links to Home and Rules, while the rules view displays matcher statistics and directs users to the rule manager for refresh operations.

apps/checker/app/views · high confidence

New rule-comparison and database-dump scripts with WASM XML parsing

Added \compare-rule-xml.js\ to detect changes in specific LanguageTool rule definitions between two XML files by reading a list of rule IDs from a text file, and \dump-db.ts\ to export the \rules\_draft\ table from a PostgreSQL database to CSV. The comparison script now uses \libxml2-wasm\ for XML parsing instead of the previously used \libxml2js\, addressing a critical vulnerability in the older library.

script/js · high confidence

New unified start script and dedicated service launchers

Developers can now use the new \script/start\ command to launch both the rule checker and rule manager services simultaneously, replacing previous ad-hoc startup methods. This entry point delegates to new \script/start-checker\ and \script/start-manager\ scripts, which handle service-specific setup such as running pre-flight checks, configuring debug modes, and managing Docker dependencies via \docker compose\. The \start-manager\ script also ensures that the client application is built and started in watch mode, and automatically tears down Docker containers and kills background processes on exit.

script · high confidence

Removal of legacy Play Framework configuration and routing files

The legacy \conf/application.conf\ and \conf/routes\ files have been deleted. This removes the default Play Framework application loader configuration and the hardcoded route definitions for the home (\/\) and check (\/check\) endpoints, indicating a migration away from the standard Play routing and configuration structure.

conf · high confidence

Removal of legacy Rule and RuleMatch model classes

The legacy \Rule\ and \RuleMatch\ case classes, which previously wrapped LanguageTool's rule and match objects for JSON serialization, have been removed from the \app/model\ directory. This change eliminates the old data structures that mapped directly to \org.languagetool.rules\ entities, reflecting a shift in the internal model architecture to support more complex matching logic and multiple matcher types.

app/model · high confidence

Removal of legacy application bootstrap and utility code

The application's previous bootstrap structure, including the \AppComponents\ and \AppLoader\ classes that wired the \ApiController\ and \LanguageTool\ instance, has been removed. Additionally, the \JsonImplicits\ utility object, which provided JSON serialization for \URL\ objects, has been deleted. These changes indicate a shift away from the previous Play Framework component wiring and JSON handling approach.

app · high confidence

Support for Vite development server and stage-dependent assets

The rule-manager view now loads frontend assets via the Vite development server (localhost:5173) when the application stage is set to 'dev', enabling hot module replacement during development. For non-development stages, it falls back to serving static build files from the /build directory. Additionally, the view now injects a stage-specific favicon and passes user permission data and telemetry configuration to the frontend via script tags and a JSON data block.

apps/rule-manager/app/views · high confidence

Test coverage

Added database integration tests for rule and tag management; Added test coverage for checker services and performance simulation; Added test coverage for dictionary, language tool, and regex matchers; Added test fixtures for CAPI responses and rule generation; Added test fixtures for rule-manager resources; Added test resources for Gatling simulations and spell-checker dictionary; Added tests for CheckerRuleForm validation; Added tests for dictionary XML parsing utilities; Added tests for rule testing service; Added tests for the Timer utility; Added unit tests for text range and block manipulation logic; Fixture now includes groupKey in RuleMatch; Removal of HomeControllerSpec test suite; Updated CDK infrastructure snapshot for Typerighter stack.

Dependencies

Initial dependency setup for rule-manager client, CDK, and utility scripts

This change introduces the initial dependency manifests and lockfiles for three new areas: the rule-manager client (apps/rule-manager/client), the CDK infrastructure code (cdk), and a JavaScript utility script (script/js). The rule-manager client is configured with React 17, Vite 4.5.9, TypeScript 4.5.3, and the Elastic EUI library v84.0.0. The CDK project pins the AWS CDK library to v2.1100.3 and the Guardian CDK to 62.3.2. The script/js package adds dependencies for PostgreSQL interaction (pg v8.13.1) and XML processing (libxml2-wasm v0.4.1).

(dependencies) · high confidence

Upgrade Play framework to 2.9.10 and update build tooling

The project has upgraded the Play framework from version 2.6.20 to 2.9.10, which addresses security vulnerabilities in underlying dependencies like Jackson. The build environment has also been updated, bumping sbt to version 1.12.6 and adding several new plugins including Gatling for testing, SBT Riff-Raff for artifact management, and ScalikeJDBC for database model generation.

project · 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

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 46 → 38 (-8.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 53 → 53 (+0.0)
  • Architecture 46 → 62 (+15.6)
  • Maturity 73 → 77 (+4.2)
  • Readiness 35 → 28 (-7.1)
  • Security 74 → 63 (-11.1)
  • Accessibility 30 (new)
  • Performance 100 → 100 (+0.0)

Resolved (40)

  • Documentation: contradicts the code (docs/decision-records/001-management-service.md)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (apps/rule-manager/client/package-lock.json)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • Medium CVE: [GHSA redacted] (apps/rule-manager/client/package-lock.json)
  • Medium: security finding (details withheld)
  • Off-boarding risk: anonymized user #1
  • Outdated: at.yawk.lz4:lz4-java
  • Outdated: ch.qos.logback:logback-classic
  • Outdated: com.fasterxml.jackson.module:jackson-module-scala_2.13
  • Outdated: com.google.api-client:google-api-client
  • Outdated: com.google.guava:guava
  • Outdated: com.gu:content-api-client-default_2.13
  • Outdated: com.gu:content-api-models-json_2.13
  • Outdated: com.gu:content-api-models-scala_2.13
  • Outdated: com.gu:editorial-permissions-client_2.13
  • …and 20 more

New (16)

  • Classify ADR enforcement: Checker: handling capitalisation in the regex matcher at sentence starts (docs/decision-records/001-regex-matcher-capitalisation.md)
  • Classify ADR enforcement: Typerighter rule management service architecture (docs/decision-records/001-management-service.md)
  • Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (cdk/yarn.lock)
  • High CVE: [GHSA redacted] (build.sbt)
  • Low CVE: [GHSA redacted] (apps/rule-manager/client/package-lock.json)
  • Low CVE: [GHSA redacted] (cdk/yarn.lock)
  • Medium CVE: [GHSA redacted] (cdk/yarn.lock)
  • Off-boarding risk: anonymized user #1

Changes since last survey

  • 9 commits — 9 feature/other, 0 fixes

By area

  • (root) — 3 commits
  • .github/workflows — 3 commits
  • (repo) — 2 commits
  • script/lib — 1 commit

Notable commits

  • change: update setup actions to pinned releases, node checks for latest release
  • change: Bump panda auth to pull in patched dependencies
  • change: Merge pull request #680 from guardian/ld/oct-2026-vulns-again
  • change: Merge pull request #681 from guardian/dblatcher/major-tools-versions
  • change: change tools files to major versions
  • change: don't use check-latest on setup-node
  • change: only compare major version of node
  • change: remove .nvmrc, update check-node-version to read .tool-versions
  • change: restore cache config

Architecture

  • Containers 0 added · 1 removed · contexts 0 added · 0 removed · edges 0 added · 0 removed

Removed containers (1)

  • cli:%name.PascalCased%.template

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

Survey your own repository

guardian/typerighter 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 f35df83162ae10c5d1d610fe914718c85afc293f — 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-60d1b390edf0.