Automattic/harper

Harper is a privacy-focused, on-device grammar and spell-checking engine built in Rust that provides real-time language analysis across a wide variety of text formats and programming environments. It powers a suite of integrations including a macOS desktop application, browser extensions, and plugins for editors like VS Code and Obsidian, as well as a language server for broader IDE support. The system features a highly configurable rule engine with custom DSL capabilities, allowing for precise detection of grammatical errors, style issues, and spelling mistakes while ensuring all processing occurs locally without sending data to external servers.

48 changes.

The project underwent a fundamental architectural overhaul of the harper-core engine, replacing legacy tokenization with a high-performance FST-based dictionary, Brill POS tagging, and a new pattern-based linting system. This core modernization was accompanied by the release of a dedicated language server (harper-ls) and a standalone WebAssembly library (harper.js), enabling on-device grammar checking across VS Code, Obsidian, and web environments. Concurrently, the team expanded language support to include HTML, Literate Haskell, and extensive programming language comments, while rebuilding the marketing website with Svelte 5.

44 changes.

This period focused on extending Harper's language coverage by adding parsers for Typst, Ink, Python, and commit formats, while significantly enhancing core grammar rules for common confusions like pronouns and homophones. Simultaneously, the project launched comprehensive browser extensions for Chrome and WordPress, alongside a new web-based linting framework and analytics infrastructure to support real-time editing and user feedback.

32 changes.

This period focused on launching the Harper Desktop application for macOS and Windows, featuring a Tauri-based architecture with system-wide accessibility integration and screen highlighting. Concurrently, the core linting engine was extended with new document parsers for Asciidoc and TeX, a domain-specific language for custom grammar rules called Weir, and a structured thesaurus system.

Users can now lint Asciidoc files. This change introduces the \AsciidocParser\ which uses tree-sitter to parse Asciidoc syntax and applies the standard grammar and spell-checking linters to the extracted text content.

harper-asciidoc · high confidence

A new CommonJS-based example (\commonjs-simple\) has been added to demonstrate how to use harper.js v2.4.0 in a Node.js environment. The example illustrates initializing a \LocalLinter\ with the American English dialect and performing linting, specifically noting that \WorkerLinter\ is not supported in Node.js due to reliance on web-specific APIs.

packages/harper.js/examples/commonjs-simple · high confidence

A new server route has been added to handle update checks for the Harper Desktop application. This endpoint accepts the target platform, architecture, and current version, then queries GitHub for the latest release. It verifies if an update is available, retrieves the corresponding archive and signature assets, and returns the update details (version, download URL, signature) to the client. It also increments a counter for update check requests and caches signatures to reduce external API calls.

packages/web/src/routes/download-harper-desktop · high confidence

The harper-python package now includes a new Python parser that recognizes module-level, function, class, and attribute docstrings for linting. This enables the tool to analyze text within Python docstrings, including handling indentation in multiline docstrings to avoid false positives with specific rules like French spacing.

harper-python · high confidence

The web application now includes a database layer using Drizzle ORM to persist user-submitted feedback and usage metrics. This introduces database schemas and model classes for tracking domain review submissions, problematic linter reports, uninstall feedback, and daily update check counts, enabling the system to store and retrieve this data for reporting and analysis.

packages/web/src/lib/db · high confidence

A new linting rule has been added to detect and correct common confusions between the words 'hop' and 'hope'. The linter identifies two specific error patterns: it suggests replacing 'hop' with 'hope' when used in contexts like 'I hop we can clarify this', and it suggests replacing 'hope' with 'hop' when referring to boarding transportation, such as 'hop on a bus' or 'hop on a call'.

_harper-core/src/linting/hop\hope · high confidence

Users can now lint commit descriptions written in the jjdescription format, which supports both simple text and conventional commit styles. The new parser automatically ignores lines prefixed with 'JJ:' and treats the remaining content as Markdown, allowing the linter to catch typos in the actual commit message while disregarding metadata or diff snippets.

harper-jjdescription · high confidence

A new \raw-web\ example has been added to demonstrate how to use \harper.js\ directly in a plain HTML page using a CDN. The example imports the library via native ECMAScript modules from unpkg (version 2.4.0) and utilizes \WorkerLinter\ to perform non-blocking grammar checks on user input, displaying results in real-time within the browser.

packages/harper.js/examples/raw-web · high confidence

A new page at /request-browser-support has been added to the web application. This page displays an embedded Google Form that allows users to submit requests for support for specific websites.

packages/web/src/routes/request-browser-support · high confidence

The Chrome extension now supports linting within Google Docs documents. This is implemented by introducing a new bridge client and layout parser that communicate with a main-world script to extract text and rect information from the Google Docs editor, allowing the extension to detect and correct spelling and grammar errors in real-time within Google Docs.

packages/chrome-plugin/src/contentScript · high confidence

Users can now analyze Ink scripting files for grammar and style issues. This change introduces an InkParser that uses tree-sitter to identify content, comments, and code structures, applying standard English linting rules to the text while ignoring structural syntax like knots and stitches. Test cases verify that the parser correctly handles various Ink constructs, including comments, strings, and choice blocks.

harper-ink · high confidence

The web library now includes a new GitHub client for fetching and caching the latest release metadata and asset URLs, supporting the application's auto-update mechanism, alongside a factory function to initialize the Harper.js linter within a web worker for the standalone web editor.

packages/web/src/lib · high confidence

The Chrome extension now includes a new bridge layer to integrate with Google Docs. This change adds three new files in the public directory: a protocol definition (\google-docs-protocol.js\) specifying request/response types for text operations, a main-world bridge script (\google-docs-bridge.js\) that syncs document text, selection, and layout changes, and a request handler (\google-docs-bridge-request-handler.js\) that processes commands like getting text rects and replacing text. This enables the extension to interact with Google Docs content directly.

packages/chrome-plugin/public · high confidence

A new presentation page has been added at the \/presentation\ route, utilizing Reveal.js to display a slide deck about the Harper grammar checker. The slides cover the project's context, mission, and features, including its privacy-focused, on-device operation and current availability in Neovim and Web.

packages/web/src/routes/presentation · high confidence

A new demo page has been added at /languagedetection to showcase Harper's language detection capabilities. This page allows users to input text or select from predefined templates (including mixed-language examples like Spanglish) to see if the content is likely English and to view the English portions isolated from the rest. It serves as an interactive demonstration of the underlying detection logic used for features like redacting commented-out code.

packages/web/src/routes/languagedetection · high confidence

Users can now run a new native example (alloc\_profile.rs) to count heap allocations made by fuzzy\_match across benchmark word lists, aiding performance tuning for WASM environments where allocation is expensive. Additionally, a new Node.js-based benchmark harness (wasm\_bench.js) has been added to measure fuzzy\_match time and throughput in WASM, using the same word lists and parameters as the native benchmarks to ensure comparability.

harper-core/examples, harper-wasm/benches · high confidence

A new GET endpoint at /cache-healthcheck has been added to the website. It returns a simple 'OK' response with a 'Cache-Control: no-cache' header, allowing users or monitoring systems to verify that the cache layer is responsive and not serving stale data.

packages/web/src/routes/cache-healthcheck · high confidence

Users can now submit feedback about specific domains where the application is not working as expected. This change introduces a new Domain Review page and corresponding API endpoints that allow users to report whether a domain is problematic, specify if issues are false positives, and provide additional context, which is then stored for review.

packages/web/src/routes/api · high confidence

The fuzz directory now includes example fuzzing targets for Harper's core markdown, HTML, Typst, and comment parsers, along with a README and .gitignore to support local fuzzing workflows using cargo-fuzz. The comment parser target specifically exercises language support for 35 languages, including newly added ones like Elixir and Zig, allowing developers to automatically generate test inputs and detect crashes or infinite loops in the parsing logic.

fuzz · high confidence

The static assets directory now includes configuration files and SVGs to support social sharing previews and browser-specific icons. Specifically, a web manifest (site.webmanifest) and browser configuration file (browserconfig.xml) have been added to define app-like behavior and tile colors, while new SVG files (harper-logo.svg, safari-pinned-tab.svg) provide the visual assets for these icons.

packages/web/static · high confidence

Users who uninstall the Harper browser extension are now presented with a dedicated page asking for feedback on their decision. This new route displays a form with predefined reasons for uninstalling (such as confusion, language support, performance, or accuracy issues) and allows users to provide custom feedback via an 'Other' option, submitting their response to the backend API.

packages/web/src/routes/uninstall-browser-extension · high confidence

New admin routes have been added to display analytics for user-submitted domain problem reports, Chrome extension uninstall feedback, and problematic lints. Each section provides a dashboard that aggregates counts by domain, feedback reason, or lint rule ID, filtered by time ranges (last day, last 30 days, or all time), and presents the data using the shared AnalyticsPage component.

packages/web/src/routes/admin · high confidence

The CI pipeline now automatically builds, signs, and notarizes the macOS desktop application. This change introduces Buildkite steps and Fastlane lanes that fetch Developer ID certificates from S3, compile the app for Apple Silicon (and universal builds on main/tags), and submit the resulting .app and .dmg files to Apple for notarization. It also adds logic to publish draft GitHub releases with the signed artifacts attached, ensuring Gatekeeper accepts the software without warnings.

.buildkite, fastlane · high confidence

A new \harper-stats\ crate has been added to centralize Harper's statistics logging. It provides a \Stats\ struct that records lint applications (including lint kind, context tokens, and configuration updates) as JSON rows, and offers a \summarize\ method to aggregate these records into a \Summary\ containing counts per lint kind, total applied suggestions, and the most common misspelled words.

harper-stats · high confidence

The Chrome extension background script now automatically determines the user's preferred English dialect (American, British, Australian, Canadian, or Indian) by reading the browser's UI language via the chrome.i18n API, falling back to navigator.language if necessary. This new detection logic, implemented in detectDialect.ts and integrated into the background index, ensures that linting rules and suggestions align with the user's regional spelling conventions without requiring manual configuration.

packages/chrome-plugin/src/background · high confidence

Users can now ignore specific lints based on their surrounding context rather than just the lint type. The new \IgnoredLints\ system captures the lint kind, message, and surrounding tokens to create a unique hash, allowing users to suppress individual occurrences of a rule without disabling the rule entirely.

_harper-core/src/ignored\lints · high confidence

The database schema has been extended with new tables to support user feedback and usage analytics. A new \uninstall\_feedback\ table captures user comments during uninstallation, while a \problematic\_lint\ table (with an added \rule\_id\ column) stores details about linting issues. Additionally, a \domain\_review\ table allows users to report on site support, and an \update\_check\_counts\ table tracks the frequency of update checks by date.

packages/web/drizzle · high confidence

The \packages/harper.js/src\ directory has been restructured into a dedicated abstraction layer for Harper's core linting engine. This change introduces a unified \Linter\ interface that supports both synchronous (\LocalLinter\) and asynchronous (\WorkerLinter\) execution, allowing applications to choose between blocking and non-blocking linting without changing their API usage. The new module provides lazy WebAssembly loading via \BinaryModule\ to optimize startup performance, and exposes a rich configuration system including structured lint settings, dialect selection, and English isolation. Additionally, it adds support for importing and exporting ignored lints, managing custom dictionaries, and loading external rule sets via the new \Weirpack\ format (pack/unpack utilities and \loadWeirpackFromBlob\/\loadWeirpackFromBytes\ methods).

packages/harper.js/src · high confidence

The harper-html module now provides an HtmlParser that tokenizes HTML content by extracting text nodes via tree-sitter. A key behavioral change in this parser is the normalization of whitespace: multiple consecutive spaces in the source are condensed into a single space, aligning with the behavior of most standard HTML parsers.

harper-html/src · high confidence

This change introduces the core parsing infrastructure for the new Weir language, located in \harper-core/src/weir/parsing\. It adds the ability to lex and parse Weir source code into an Abstract Syntax Tree (AST), supporting features such as variable declarations (\let\), expression assignments (\expr\), and specific test directives (\allows\, \test\). The parser also handles expression syntax including word tokens, punctuation, sequences, arrays, filters, and negation. Additionally, it implements an LRU cache for parsed ASTs to optimize performance for repeated parsing requests.

harper-core/src/weir/parsing · high confidence

This change introduces the initial Tauri-based desktop application configuration for Harper (version 2.10.0), establishing the core build scaffolding and project identity. It configures the app to bundle for all targets, sets the product name to 'Harper', and enables the auto-update plugin pointing to the official download endpoints, allowing users to receive updates automatically.

harper-desktop/src-tauri · high confidence

This entry introduces harper-core, the fundamental Rust engine powering the Harper private grammar checker. It provides a public API for integrating high-quality grammar and spell-checking into applications, featuring a curated dictionary, affix-based word expansion, and a comprehensive suite of linters for grammar, style, and proper nouns. The release includes configuration files for dialects and linting groups, data structures for irregular nouns and verbs, and a build system that compiles Weir rule files into the engine.

harper-core · high confidence

This change introduces the \harper-ls\ language server, providing real-time grammar and spell-checking diagnostics for a wide variety of file types including Markdown, HTML, Python, Rust, TeX, Typst, Org Mode, Asciidoc, and Git commit messages. The server supports configurable user, file, and workspace dictionaries, allows users to ignore specific lints, and offers code actions to fix issues or add words to dictionaries. It integrates with LSP clients via TCP (defaulting to 127.0.0.1:4000) or standard I/O, and includes settings for diagnostic severity, dialect selection, and file exclusion patterns.

harper-ls/src · high confidence

This change introduces the Harper Chrome extension, providing in-browser grammar and style checking. The extension features a popup interface with onboarding and error reporting, configurable hotkeys, and support for dark mode. It includes content scripts for general web pages and specific support for Google Docs, with domain-level enable/disable controls and a user dictionary. The extension communicates with a background service worker via a defined protocol for linting, configuration, and dictionary management, and is built using Manifest V3 with support for both Chromium and Firefox browsers.

packages/chrome-plugin, packages/chrome-plugin/src · high confidence

This change introduces the Harper VS Code extension, a grammar and style checker for code comments that runs on-device. The package includes the necessary build configuration (esbuild, TypeScript) to bundle the extension, along with documentation and installation instructions for users.

packages/vscode-plugin · high confidence

The repository is initialized with essential configuration files and documentation. This includes a Dockerfile and docker-compose files for building and running the Harper website with a MariaDB backend, a justfile for managing build and development tasks, and a Nix flake for setting up the development shell. Project standards are enforced via .editorconfig (LF line endings), .gitattributes, and a Biome configuration for JavaScript/TypeScript formatting and linting. The repository also introduces version pinning files for Node.js, Ruby, and Xcode, alongside foundational documentation such as AGENTS.md, AGENT\_POLICY.md, ARCHITECTURE.md, CONTRIBUTING.md, and a comparison with other grammar checkers.

(repo-wide) · high confidence

Added a new TeX parser that wraps the standard PlainEnglish parser to handle TeX, LaTeX, and derivative languages. This parser masks LaTeX-specific syntax—including commands, math environments (such as equation, align, and math modes), comments, and indentation—so that only the visible text is grammar-checked. It also normalizes TeX punctuation by converting triple hyphens (---) into em-dashes and double hyphens (--) into en-dashes.

harper-tex/src · high confidence

This change introduces the Harper Desktop application, built on Tauri, which provides a system tray interface and a background highlighter service. The service runs as a separate process to perform real-time text linting and accessibility integration, with a debouncing mechanism to optimize performance. Users can manage the service via the tray menu, access settings and an editor window, and configure options such as dialect, auto-updates, and debounce timing through centralized commands.

harper-desktop/src-tauri/src · high confidence

Added a new screen highlighter system in the desktop application that creates transparent, click-through overlay windows on each monitor to visualize grammar and spelling lints. The implementation uses egui and wgpu to render highlight rectangles and interactive suggestion popups, allowing users to apply suggestions, ignore lints, or add words to the dictionary directly from the screen. This feature introduces a new \Highlighter\ module with components for error handling, render state management, and window lifecycle control.

harper-desktop/src-tauri/src/highlighter · high confidence

The WordPress plugin now includes a dedicated Harper sidebar that provides real-time grammar, spelling, and style checking within the Gutenberg editor. Users can view detected issues directly on the text via underlines and popovers, apply suggested fixes, add words to a personal dictionary, or ignore specific lints. The sidebar also features a Settings tab where users can configure linting rules and select from multiple English dialects (American, Canadian, Australian, British, and Indian).

packages/wordpress-plugin/src · high confidence

This change introduces the \packages/harper.js\ package, providing a new way to integrate Harper's grammar checking capabilities into web and Node.js applications. The library is designed to run entirely on-device via WebAssembly, ensuring no data leaves the user's browser or environment. It exposes multiple entry points for loading the WASM binary (standard, slim, inlined, and lazy-loaded) to accommodate different bundling and performance needs, and includes a build configuration (Vite) and documentation generation scripts to support developers integrating the tool.

packages/harper.js · high confidence

Added a new \harper-typst\ crate that enables Harper to parse and lint Typst documents. This parser translates Typst syntax trees into Harper tokens, handling specific Typst features such as converting newlines after headings and list items into paragraph breaks, correctly processing contractions, and ignoring specific Typst constructs like \.display\, regex patterns, and file-path arguments to prevent false positives.

harper-typst/src · high confidence

Adds a new Visual Studio Code extension that integrates the Harper language server. The extension supports linting for standard file-based documents as well as untitled buffers, and specifically handles the Source Control commit message box (scminput) by activating on language rather than file scheme. It includes a clickable status bar item for changing the English dialect, respects a custom \harper.path\ setting to locate the bundled or external language server binary, and notifies the server of configuration changes without requiring a full restart. Users are prompted to save untitled files before executing dictionary-add commands.

packages/vscode-plugin/src · high confidence

Users can now define custom grammar checks using Weir, a new programming language located in \harper-core/src/weir\. This feature introduces an Abstract Syntax Tree (AST) and a parser that translates Weir scripts into executable linters. The language supports defining expressions, variables, and tests, and allows users to specify lint metadata such as descriptions, messages, replacement strategies, and scope (chunk or sentence). This provides a flexible, code-based way to extend the tool's linting capabilities beyond built-in rules.

harper-core/src/weir · high confidence

Users can now bundle Weir grammar rules and Rune dictionaries into a single distributable package called a Weirpack. This new format supports a JSON manifest (requiring author, version, description, and license) and allows packages to include .weir rule files, a dictionary.dict file, and an annotations.json file. The system provides APIs to load, validate, and convert these packages into active linting groups, enabling easier sharing and installation of custom grammar checking capabilities.

harper-core/src/weirpack · high confidence

Added a new \WindowsBroker\ implementation in \harper-desktop/src-tauri/src/windows\_broker\ that leverages the Windows UI Automation API to read text from the currently focused application, compute bounding boxes for lint suggestions, and apply corrections directly. This component also handles querying installed applications, retrieving application icons, and respecting user-configured integration settings to determine which windows should be linted.

_harper-desktop/src-tauri/src/windows\broker · high confidence

A new WorkerLinter implementation has been added to the harper.js package, which offloads linting operations to a dedicated Web Worker. This change prevents the main thread from blocking during the processing of large documents, ensuring a smoother user experience. The implementation includes the main linter class, a worker script that handles the actual linting logic via a local linter instance, and necessary shims for test environments.

packages/harper.js/src/WorkerLinter · high confidence

The harper-comments crate now provides a dedicated CommentParser that uses tree-sitter to isolate comments from source code across a wide range of languages (including C, Java, JavaScript, Python, Go, Rust, and many others). It wraps a language-specific comment parser (such as JavaDoc or JsDoc) with a masker that respects IDE spell-checker ignore directives (e.g., spellchecker:ignore, harper:ignore) and correctly handles shebang lines, ensuring only relevant comment text is linted.

harper-comments/src · high confidence

Adds a new command-line tool, \harper-cli\, designed for checking large numbers of files automatically (e.g., in CI). It supports linting files, directories, and direct text input, with automatic language detection for Markdown, TeX, Python, Org Mode, and more. Users can control output via \--format\ (default, JSON, or compact), disable colors with \--no-color\ or the \NO\_COLOR\ environment variable, and configure dialects and dictionaries. The tool also includes subcommands for parsing, visualizing spans, annotating tokens, and retrieving word metadata.

harper-cli · high confidence

A new harper-thesaurus crate provides a read-only, thread-safe thesaurus that loads a ZSTD-compressed word list at startup. It exposes two lookup methods: get\_synonyms returns all synonyms for a word, while get\_synonyms\_freq\_sorted returns them ordered by usage frequency. The build script compresses thesaurus.txt into a static binary blob, using a lower compression level in debug builds to speed up compilation.

harper-thesaurus · high confidence

The Harper Desktop highlighter process now communicates with the main Tauri application via a new async JSON-over-line protocol. This allows the highlighter to request and update configuration state—including lint rules, dictionaries, dialects, debounce timing, ignored lints, and editor integrations—while ensuring the highlighter exits cleanly if the parent server becomes unresponsive.

harper-desktop/src-tauri/src/communication · high confidence

Users can now use regular expressions to mask out specific sections of text from Harper's analysis. This change introduces a \Masker\ trait and a \RegexMasker\ implementation that allows users to either exclude regex matches from being parsed or include only those matches. This capability enables features like ignoring code comments or specific patterns in documents, improving the relevance of linting and analysis by focusing only on the desired text segments.

harper-core/src/mask · high confidence

The \packages/harper-editor\ directory is now a self-contained SvelteKit package that provides a new web-based editor interface. This update introduces a redesigned UI featuring a dedicated lint sidebar (\LintSidebar.svelte\) that displays problems with expandable cards (\LintCard.svelte\) and a status bar (\StatusBar.svelte\) for word/character counts and font customization. The editor integrates with the \harper.js\ linter via a \LintFramework\ to show real-time grammar and spelling issues, and includes a \LazyEditor\ component for performance optimization. The package exports the \Editor\ and \LazyEditor\ components along with necessary types, establishing a new foundation for the web editor experience.

packages/harper-editor · high confidence

This change establishes a new, robust configuration system for the desktop application, replacing ad-hoc state handling with a dedicated \Config\ struct and serialization logic. It introduces platform-aware integration support, where macOS applications are pre-configured for integration while Windows and other platforms start with an empty list, allowing the UI to manage integrations via bundle IDs. Additionally, the system now persists the onboarding completion status, ensuring the onboarding flow is skipped for returning users, and includes error handling for configuration directory access and serialization.

harper-desktop/src-tauri/src/config · high confidence

This change adds the \harper-pos-utils\ crate, providing core utilities for part-of-speech processing. It defines the Universal POS (UPOS) tagset and includes a new Brill tagger implementation alongside a chunker built with the Burn framework. The library also exposes helpers for parsing CONLLU files and counting word frequencies, which are gated behind a \training\ feature flag.

harper-pos-utils/src · high confidence

Harper Desktop is a new standalone macOS application that brings the Harper grammar checker to your desktop. It features an offline Markdown editor, a comprehensive settings interface for managing dialects, linting rules, and a user dictionary, and an integrations system that allows Harper to check text in other applications via macOS Accessibility permissions. The app includes an onboarding flow to guide users through setup, supports auto-updates, and provides global keyboard shortcuts for quick access.

harper-desktop/src · high confidence

A new server route at /latestversion has been added to the web package. This endpoint queries the GitHub API for the latest release of the 'automattic/harper' repository and returns the version string to clients. It includes CORS headers to allow cross-origin requests and sets a no-cache policy to ensure clients always receive the most current version information.

packages/web/src/routes/latestversion · high confidence

The harper-pos-utils chunker and tagger modules now include new implementations based on Eric Brill's transformation-based learning (BrillChunker and BrillTagger) and a neural network chunker using the Burn framework (BurnChunker). The Brill implementations allow for training patches to refine base frequency-dictionary tagging and chunking, while the Burn chunker provides a BiLSTM-based approach for noun phrase identification. Additionally, a CachedChunker wrapper is introduced to add LRU caching to any chunker implementation for performance optimization.

harper-pos-utils/src/chunker · high confidence

The harper-brill module now includes trained models for a Brill part-of-speech tagger and chunker, along with a new Burn-based neural chunker. Users can access these via the new \brill\_tagger()\, \brill\_chunker()\, and \burn\_chunker()\ functions, which provide lazily-initialized, shared instances for improved performance. The Brill models are loaded from embedded JSON files (\trained\_tagger\_model.json\ and \trained\_chunker\_model.json\), while the Burn chunker uses a pre-trained model file (\model.mpk\) and vocabulary (\vocab.json\).

harper-brill · high confidence

A new marketing page for Harper Desktop has been added at /desktop, clearly stating that the application is currently in beta and highlighting its local, private grammar-checking capabilities for macOS. The page details system requirements (macOS 14+), supported apps, and customization features. Additionally, a new download endpoint at /desktop/download has been implemented to automatically redirect users to the latest universal macOS DMG release from the GitHub repository.

packages/web/src/routes/desktop · high confidence

The spell-checking engine now includes a new 'Rune' module that parses JSON-based affix and property definitions to expand dictionary entries. This system supports prefix and suffix rules with conditional replacements (using a regex-like matcher), cross-product expansions (combining multiple affixes), and the propagation of metadata (such as part-of-speech or plural status) to derived word forms. Users benefit from more accurate morphological analysis and spell-checking for inflected words based on these configurable rules.

harper-core/src/spell/rune · high confidence

A new page at /titlecase has been added to the web application, allowing users to convert text to title case following Chicago Style. The page features a text input area that automatically converts entered text using the Harper linter running in a Web Worker, and includes a typing animation to guide users on how to use the tool.

packages/web/src/routes/titlecase · high confidence

A new \ToTwoToo\ linting rule has been introduced to detect and correct the common confusion between the words \to\ and \too\. This rule is composed of several specialized sub-linters that handle various grammatical contexts, including usage before adjectives, adverbs, and degree words (like \many\ or \much\), as well as at the end of sentences or clauses. It also covers the reverse case where \too\ is incorrectly used before verbs, pronouns, or nouns. The linter is designed to minimize false positives by ignoring valid uses of \to\ (such as in infinitives or prepositional phrases) and \too\ (such as in proper nouns or when followed by specific determiners).

_harper-core/src/linting/to\_two\too · high confidence

A new studio page has been added at the weir route, providing a browser-based interface for users to create, edit, and manage Weirpacks. This feature includes an integrated code editor for writing rules, functionality to upload and unpack .weirpack archives, and the ability to save and load projects via local storage.

packages/web/src/routes/weir · high confidence

Added a suite of Svelte components to support the Weir Studio interface and reporting features. This includes \WeirStudioWorkspace\, \WeirStudioFileExplorer\, and \WeirStudioStart\ for managing file-based Weirpacks, alongside \AnalyticsPage\, \BarChart\, \LintKindChart\, and \Graph\ for visualizing linting data. Also added \Loader\ for animated loading states, \Toasts\ for user notifications, and \DefaultNeovimConfig\ for generating and copying configuration snippets.

packages/web/src/lib/components · high confidence

The linting engine now uses a new \Expr\ trait and a suite of composable expression types (such as \SequenceExpr\, \AnchorStart\, \AnchorEnd\, \DurationExpr\, and \PronounBe\) to define grammar checks. This shift replaces the previous pattern-matching approach with a declarative system that makes rules easier to read and write, enabling more precise detection of grammatical errors like missing verbs, incorrect pronoun usage, and duration mismatches.

harper-core/src/expr · high confidence

The lexer now recognizes URLs, email addresses, and hostnames as distinct token types rather than treating them as generic words or numbers. This change introduces specific parsing logic for these structures, including validation for email local parts and domain names, and ensures that URLs are parsed according to standard scheme and path rules. Users will see more accurate tokenization of web addresses and contact information, which improves downstream grammar and style checking for these common text patterns.

harper-core/src/lexing · high confidence

The harper-dictionary-wordlist crate now exposes public async functions to save a dictionary to a file and load a dictionary from a file on disk. This allows users to persist and restore Harper dictionaries using standard wordlist files, with the saved output ensuring words are sorted alphabetically.

harper-dictionary-wordlist · high confidence

A new route at /editor has been added that renders the text editor inside an \<Isolate\> wrapper, specifically designed to be embedded via an iframe. The page disables server-side rendering and initializes the editor asynchronously by loading a linter on mount, accepting optional initial text via the 'initialText' URL search parameter.

packages/web/src/routes/editor · high confidence

A new linter for git commit messages has been added, utilizing tree-sitter to parse the commit structure. This parser intelligently ignores git-specific metadata (such as diff blocks and comment lines starting with '\#') and focuses on the subject, message body, and breaking change sections. It also normalizes whitespace to ensure consistent linting results across different commit formats.

harper-git-commit · high confidence

Added a new linting rule that detects and corrects the common misuse of 'criteria' and 'phenomena' as singular nouns, and 'criterion' and 'phenomenon' as plural nouns. The linter now suggests replacing 'criteria' with 'criterion' when preceded by singular modifiers like 'one' or 'this', and suggests replacing 'criterion' with 'criteria' when preceded by plural modifiers like 'three' or 'these'.

_harper-core/src/linting/criteria\phenomena · high confidence

The \harper-comments\ crate now includes dedicated comment parsers for Go, JavaDoc, JSDoc, Lua, and Solidity, alongside a generic \Unit\ parser. These parsers strip language-specific comment initiators (like \//\, \/\*\, or \--\) and delegate to underlying Markdown or HTML parsers, ensuring that linting rules apply only to the actual comment content. The JSDoc and JavaDoc parsers specifically handle inline tags (e.g., \{@link}\) and block tags (e.g., \@param\) by marking them as unlintable, preventing false positives on code references and metadata. The Go parser handles \go:\ directives, while the Solidity parser ignores SPDX license identifiers.

_harper-comments/src/comment\parsers · high confidence

A new \lint-framework\ package has been introduced to centralize the logic for reading and writing text in web-based text editors, rendering lint underlines, and displaying the suggestion UI. This framework decouples the core linting capabilities from the browser extensions, enabling the same linting and review experience to be used in other contexts, such as the Harper website demo. It provides a unified interface for handling various editor types (including Google Docs, Quill, and standard contenteditable fields) and manages the rendering of highlights and suggestion popups.

packages/lint-framework · high confidence

A new linting module in harper-core now identifies mass nouns used as countable nouns. It flags pluralized mass nouns (e.g., 'advices', 'source codes', 'real estates') and suggests singular forms, while also correcting incorrect determiners or quantifiers before mass nouns (e.g., suggesting 'a piece of luggage' instead of 'a luggage', or 'much software' instead of 'many software'). The linter includes specific exceptions, such as allowing 'a software renderer' and ignoring 'a fun and fantastic' phrases.

_harper-core/src/linting/mass\nouns · high confidence

A new linting rule has been added to detect and correct the improper use of 'effect' and 'affect'. The \EffectAffect\ linter, located in \harper-core/src/linting/noun\_verb\_confusion/effect\_affect\, combines two specific checks: \AffectToEffect\ suggests replacing 'affect' with 'effect' when the context indicates a noun meaning 'result', and \EffectToAffect\ suggests replacing 'effect' with 'affect' when the context indicates a verb meaning 'influence'. The implementation uses sequence expressions to analyze surrounding tokens (such as preceding adjectives/nouns or following verbs) to determine the correct word choice, while ignoring specific exceptions like 'take effect' or 'side effect'.

_harper-core/src/linting/noun\_verb\_confusion/effect\affect · high confidence

A new \NounVerbConfusion\ linter has been added to detect and correct common mistakes where related nouns and verbs are swapped, such as using 'advise' instead of 'advice' or 'breath' instead of 'breathe'. This feature combines existing rules for 'noun instead of verb' and 'verb instead of noun' into a single module, expanding coverage to include pairs like belief/believe, breath/breathe, emphasis/emphasize, intent/intend, and weight/weigh. The linter intelligently ignores valid contexts, such as the phrase 'better advise' in 'you'd better advise', to reduce false positives.

_harper-core/src/linting/noun\_verb\confusion · high confidence

A new linting rule has been added to detect and correct common mistakes with pronoun contractions, specifically flagging the misuse of 'your' instead of 'you're' and 'were' instead of 'we're'. The linter suggests appropriate corrections for these word-choice errors while allowing valid uses of these words in other contexts.

_harper-core/src/linting/pronoun\contraction · high confidence

Added several new lint rules to correct frequent grammatical mistakes: the \APart\ linter distinguishes between 'a part' and 'apart' in phrases like 'a part from' and 'fall a part'; the \ASomeTime\ linter removes the redundant article in 'a some time'; the \AWaysToGo\ linter inserts the missing 'a' in the idiom 'ways to go'; the \AWhile\ linter enforces the correct spelling of 'awhile' versus 'a while' based on verb context; and the \AccuseOf\ linter corrects the preposition in 'accuse for' to 'accuse of'.

harper-core/src/linting · high confidence

A new linter has been added to detect and correct instances where a noun is incorrectly used in place of its verb form (e.g., 'advice' vs. 'advise'). The rule identifies these errors by analyzing context—such as preceding pronouns, modal verbs, or frequency adverbs—and suggests the correct verb form. This feature is integrated into the existing noun/verb confusion module alongside the 'effect/affect' correction rule.

_harper-core/src/linting/noun\_verb\_confusion/noun\_instead\_of\verb · high confidence

The linter now includes two new checks within the \lets\_confusion\ module to help users distinguish between the verb 'let' (meaning permit) and the contraction 'let's' (meaning let us). The \LetUsRedundancy\ rule flags phrases like 'let's us do' or 'let's me do', suggesting 'lets us do' or 'lets me do' instead, as the contraction already includes 'us'. The \NoContractionWithVerb\ rule detects when 'lets' is used incorrectly to suggest an action (e.g., 'lets inspect'), suggesting 'let's' or 'let us' instead. These rules work together to reduce common grammatical errors involving these similar-looking words.

_harper-core/src/linting/lets\confusion · high confidence

The macOS broker module has been replaced with a new implementation that improves how the desktop app interacts with macOS accessibility APIs and installed applications. It now features a robust accessibility activation system that handles activation retries, verifies text geometry availability, and safely manages AX attributes (including fallbacks for Electron apps). The broker also introduces a new app catalog that queries installed applications via Spotlight metadata and retrieves their icons using the \sips\ utility. Additionally, window stability checks have been added to prevent processing lints while a window is being moved, and focus tracking has been optimized to reduce expensive accessibility lookups.

_harper-desktop/src-tauri/src/mac\broker · high confidence

The website now includes a redesigned landing page, a dedicated 'Get Harper' page for browsing integrations, and a new 'Report Problematic Lint' form. The integration directory displays live version numbers for key integrations (such as Chrome and Desktop) to indicate if they are up-to-date with the core engine, and includes search and category filtering. Additionally, a WordPress demo route now redirects users to an external WordPress playground.

packages/web/src/routes · high confidence

A new installation page has been added to the web application to guide users through the Harper browser extension. The page explains the core workflow—launching a site, typing naturally, and reviewing suggestions—using embedded video demonstrations. It also includes an interactive text area for users to test the extension's functionality immediately and provides troubleshooting advice for unsupported sites, including a link to request new site support.

packages/web/src/routes/install-browser-extension · high confidence

The parser module now includes several new capabilities: the CollapseIdentifiers parser merges consecutive words separated by underscores or hyphens into a single token when they exist in the dictionary; the IsolateEnglish parser filters out non-English text chunks using language detection heuristics; and the Mask parser allows other parsers to operate only on unmasked sections of text, enabling features like masking out sensitive information. These parsers are exported from the main module alongside existing ones like Markdown and OrgMode.

harper-core/src/parsers · high confidence

The \harper-core/src/patterns\ module now provides a suite of new pattern types that allow grammar rules to match text more precisely. These include \Word\ (with case-insensitive, exact, and standard-case modes), \WordSet\ for matching a list of words, \DerivedFrom\ for matching word variants, \ImpliesQuantity\ for detecting quantity indicators, \InflectionOfBe\ for verb forms, \ModalVerb\ for modal verbs, \NominalPhrase\ for noun phrases, \PrepositionalPrecederPattern\ for specific adjectives, \RelativePronoun\ for relative pronouns, \UPOSSet\ for universal POS tags, \WhitespacePattern\, and \WithinEditDistance\ for fuzzy matching. These patterns serve as building blocks for linters to detect and correct common grammatical errors.

harper-core/src/patterns · high confidence

The Chrome extension popup has been redesigned to include an onboarding flow, a main view that lets users enable or disable Harper on the current site, and mechanisms to provide feedback. Users can now report problematic lints directly from the popup, review whether Harper works well on specific domains, and are prompted to review the extension in the Chrome Web Store 14 days after installation. The popup also displays the current version and links to GitHub, Discord, and settings.

packages/chrome-plugin/src/popup · high confidence

A new \packages/components\ library has been introduced, centralizing reusable Svelte UI elements and assets. This includes a comprehensive set of form controls (Button, Input, Select, Checkbox, Toggle, Textarea, SearchField), layout primitives (Card, Section, Panel, Collapsible, GutterCenter, SettingRow), and utility components (Link, IconButton, DelayedRender, Isolate). The package also provides a collection of SVG icons (e.g., CheckIcon, GearIcon, TrashIcon) and brand logos (e.g., AutomatticLogo, ChromeLogo, EdgeLogo), all exported via a single index for consistent usage across the application.

packages/components · high confidence

A new page at \/stats\ allows users to upload a \stats.txt\ file to visualize their writing correction history. The dashboard displays a chart of the most common types of corrections applied and a table listing the most frequently misspelled words, helping users reflect on their authorship patterns.

packages/web/src/routes/stats · high confidence

The Chrome extension now features a completely rewritten options page (Options.svelte) that allows users to manage a wide range of settings in a structured, searchable interface. Users can now configure the activation hotkey, toggle the English isolation option, set a processing delay, and manage custom user dictionaries. The page supports loading and unloading Weirpacks, exporting enabled domains, and resetting or toggling all lint rules at once. It also exposes dialect selection (including Indian English) and provides a hierarchical view of lint rule settings with group expansion and search filtering.

packages/chrome-plugin/src/options · high confidence

The linting system now supports a structured configuration format that allows users to organize rules into groups and select one rule from mutually exclusive sets (e.g., choosing between 'fellow worker' or 'coworker' for redundancy). This replaces the previous flat configuration model with a hierarchical structure that includes boolean toggles for individual rules and 'OneOfMany' selectors for related linters, while maintaining backward compatibility through conversion to the internal flat config at runtime.

_harper-core/src/linting/lint\group · high confidence

Users can now process Literate Haskell files (both bird-style and LaTeX-style formats). The new \LiterateHaskellParser\ masks out code blocks to treat the remaining text as Markdown for grammar checking, while the \LiterateHaskellMasker\ provides utilities to extract code-only segments for identifier dictionary generation.

harper-literate-haskell/src · high confidence

A new benchmarking harness has been added to the WebAssembly module, exposing a \PreparedWords\ struct that allows external code to measure the performance of dictionary fuzzy matching. This enables users and developers to profile and optimize the speed of spell-check lookups within the WASM environment.

harper-wasm/src · high confidence

The main entry point for the lt-cli tool has been removed from the codebase. This eliminates the previous functionality that read text from 'alice.txt', tokenized it, and printed specific number tokens to the console.

lt-cli · high confidence

The \lt-core\ crate has removed its entire lexer implementation and associated tokenization types. This includes the deletion of \lexer.rs\ (which contained the \lex\_to\_end\ function and token parsing logic), \token.rs\ (defining \Token\, \TokenKind\, and \Punctuation\), \span.rs\, \line\_col.rs\, and \lint.rs\. The public API of \lt-core\ no longer exports these components, effectively stripping out the core text analysis capabilities that were previously available.

lt-core · high confidence

The \harper-core\ engine has been significantly restructured to improve performance and linting capabilities. The core \Document\ model now uses a new \FatToken\ representation and integrates a Brill POS tagger and a Burn-based chunker for deeper grammatical analysis. A new \DictWordMetadata\ system provides rich, structured data for words (including parts of speech, orthography, and dialect flags), replacing the previous flat metadata approach. The engine now features a new pattern-based linting system (\ExprLinter\) that allows for more complex and configurable rule definitions. Additionally, the codebase introduces new modules for handling casing (\case.rs\), character extensions (\char\_ext.rs\), and currency formatting (\currency.rs\), while removing legacy parsing and linting logic.

harper-core/src · high confidence

A change to existing behaviour in harper-desktop/src-tauri/icons — 2 commits, 17 files.

harper-desktop/src-tauri/icons · medium confidence · unverified

The project now configures Bundler to install Ruby gems into the local vendor/bundle directory instead of the global system path. This ensures that dependencies are isolated within the project directory, making the build environment more reproducible and preventing conflicts with system-wide gems.

.bundle · high confidence

The Weir linting rules in harper-core have been significantly expanded with dozens of new rules targeting common grammatical errors, idiomatic usage, and stylistic inconsistencies. These changes automatically correct frequent typos and non-standard phrasing, such as fixing 'a couple of more' to 'a couple more', 'along time' to 'a long time', and 'as compare to' to 'as compared to'. The update also addresses idiomatic blends like 'all well in good' (corrected to 'all well and good'), redundant phrases like 'as if though' (corrected to 'as if' or 'as though'), and missing prepositions in idioms like 'take advantage a' (corrected to 'take advantage of'). Additionally, it refines style preferences, such as standardizing 'a ok' to 'a-ok' and correcting 'at face values' to 'at face value', ensuring more consistent and professional output across documents.

_harper-core/src/linting/weir\rules · high confidence

The phrase-set linter now catches a wider range of common errors, including eggcorns like 'chomp at the bit' (corrected to 'champ at the bit') and 'further adieu' (corrected to 'further ado'), as well as typos such as 'bullocks' (corrected to 'bollocks' for nonsense) and 'digestive track' (corrected to 'digestive tract'). It also corrects usage issues like 'argument to be said' (corrected to 'argument to be made'), 'await for' (corrected to 'await' or 'wait for'), and 'constitute as' (corrected to 'constitute').

_harper-core/src/linting/phrase\_set\corrections · high confidence

The tree-sitter masking logic has been separated into its own crate, harper-tree-sitter, to improve portability. This change introduces a new TreeSitterMasker struct that implements the Masker trait, allowing users to selectively parse specific tree-sitter nodes and generate masks for comments. The implementation handles parsing source text, extracting comment spans, and converting byte-indexed spans to character-indexed spans for accurate masking.

harper-tree-sitter · medium confidence

The ItsContraction linter has been refactored to more accurately distinguish between the possessive 'its' and the contraction 'it's'. The new logic correctly ignores valid possessive uses (such as 'its own', 'its policies', or 'its new product') and specific contexts like 'at its highest', while still flagging common errors like 'its been' or 'its got'. It also adds a new rule to suggest 'it's' after opinion verbs (like 'think' or 'hope') when followed by a proper noun (e.g., 'I think its Google' → 'I think it's Google').

_harper-core/src/linting/its\contraction · high confidence

The compound noun linter now covers three specific grammatical contexts to better identify when two separate words should be merged into a single compound noun. It detects split compounds following a determiner or adjective (e.g., suggesting 'webcam' for 'web cam'), following a possessive noun (e.g., suggesting 'firmware' for 'firm ware'), and preceding an auxiliary verb (e.g., suggesting 'backpack' for 'back pack'). The linter includes specific exclusions to avoid false positives, such as ignoring 'let's' and 'that's' as possessives and ensuring proper nouns are not corrected.

_harper-core/src/linting/compound\nouns · high confidence

The PluralDecades linter has been expanded to detect and correct apostrophe usage in two-digit decade references (e.g., '80's', '90s') in addition to the existing four-digit support (e.g., '1980s'). The new logic distinguishes between decades and age ranges, suggesting the removal of the apostrophe for age ranges (e.g., 'in my 20s') while correcting decade references. It also includes context-aware rules to avoid flagging false positives such as product names (e.g., 'Windows 10's') or specific technical terms.

_harper-core/src/linting/plural\decades · high confidence

The marketing website now features a redesigned layout with a sticky header that compacts on scroll, a dedicated FAQ section, and a footer linking to Harper Desktop, browser extensions, and documentation. A new set of mockup components visually demonstrates Harper Desktop correcting text in macOS apps like Mail, Notes, and Slack, while integration tiles now include a specific entry for the Edge extension.

packages/web/src/lib/marketing · high confidence

The Obsidian plugin has been completely rewritten to introduce a dedicated sidebar for viewing and managing grammar errors, allowing users to ignore diagnostics or disable specific rules directly from the interface. The settings tab now supports a structured configuration system, enabling users to toggle individual lint rules, select from multiple English dialects (American, British, Canadian, Australian, Indian), and apply web-style lint underlines. Additionally, the plugin now supports masking text via regular expressions, ignoring files using glob patterns, and displays a status bar icon that reflects the active/inactive state of the linter.

packages/obsidian-plugin/src · high confidence

The spell-checking system in harper-core has been restructured to use a new immutable FST-based dictionary (FstDictionary) for high-performance fuzzy matching, while retaining a MutableDictionary for dynamic user additions. A new MergedDictionary allows combining multiple sources (curated, file, user, workspace) into a single view. The Dictionary trait now defines the interface for all implementations, and fuzzy match results are deduplicated and sorted by edit distance. This change improves spell-check suggestion speed and accuracy, particularly for the curated dictionary, while maintaining support for runtime dictionary modifications.

harper-core/src/spell · high confidence

The linter now includes style rules that suggest expanding the abbreviations 'config' or 'conf' to 'configuration', 'configs' to 'configurations', 'pref' to 'preference', and 'prefs' to 'preferences'. These changes promote clearer and more formal language in documentation and code comments by replacing common shorthand terms with their full equivalents.

_harper-core/src/linting/weir\_rules/ExpandConfiguration, harper-core/src/linting/weir\rules/ExpandPreference · high confidence

The website has been migrated to a new technology stack, upgrading to Svelte 5 and utilizing SveltePress for documentation generation. This change introduces Tailwind CSS for styling and configures the site to run on Node.js via the SvelteKit adapter. The new setup includes specific configuration for trusted origins to support browser extensions (Chrome and Firefox) and integrates Drizzle ORM for database interactions, alongside a WordPress demo blueprint for integration testing.

packages/web · high confidence

The Harper website has been redesigned with a new visual identity, introducing a warm amber and cream color palette and switching typography to Atkinson Hyperlegible for body text and Domine for headings. The site now supports automatic dark mode detection based on OS preferences, includes comprehensive SEO metadata (Open Graph, Twitter cards, JSON-LD schema), and integrates Algolia search verification. Additionally, the web application now includes server-side database migration handling via Drizzle ORM and conditional admin route protection.

packages/web/src · high confidence

Added HTML linting regression tests; Added Typst integration tests for linting and parsing; Added Typst test sources for complex documents, contractions, and specific issues; Added comprehensive linting tests for supported programming languages; Added integration and language-specific test suites for the VS Code extension; Added linting tests for the TeX language support; Added realistic benchmark data and harnesses for spell-check and linting performance; Added snapshot and linting test infrastructure for harper-core; Added test runner configuration for VS Code extension; Added tests for literate Haskell linting; Expanded end-to-end test coverage for the Chrome extension; Expanded test coverage for comment linting across multiple programming languages; Expanded test coverage for linter rules and edge cases; Expanded test fixtures for language-specific spell-checking.

This change introduces the \Gemfile\ and \Gemfile.lock\ to scaffold fastlane for macOS code signing, specifying \fastlane\ version 2.238.0 and the \fastlane-plugin-wpmreleasetoolkit\ version 14.6.0. Additionally, it establishes the Rust 2024 edition across the workspace by updating the \edition\ field to \2024\ in all \Cargo.toml\ manifests (including \harper-core\, \harper-cli\, \harper-desktop\, and others) and bumps the \edition\ in \package.json\ to require Node.js 22 and pnpm 10.6.3+.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 55.

• Code Health 69
• Architecture 85
• Maturity 60
• Readiness 61
• Security 49
• Domain Modelling 89
• Accessibility 56

• 300 commits — 243 feature/other, 57 fixes

• harper-core/src — 126 commits
• (root) — 35 commits
• harper-core/default_config.json — 27 commits
• packages/web — 18 commits
• harper-desktop/src-tauri — 17 commits
• harper-core/dictionary.dict — 12 commits
• .github/workflows — 11 commits
• (repo) — 10 commits
• packages/chrome-plugin — 10 commits
• harper-core/tests — 7 commits
• packages/components — 5 commits
• packages/obsidian-plugin — 4 commits
• packages/lint-framework — 3 commits
• harper-comments/tests — 2 commits
• harper-desktop/src — 2 commits
• .github/pull_request_template.md — 1 commit
• harper-cli/Cargo.toml — 1 commit
• harper-cli/src — 1 commit
• harper-core/irregular_verbs.json — 1 commit
• harper-git-commit/tests — 1 commit

• fix: Fix/slack quill editor linting (#4033)
• fix: Fixes three false positives when "A" or "B" are school test grades (#3718)
• fix: fix(chrome-ext): do not allow lint updates to run at the same time or get dropped (#3908)
• fix: fix(chrome-ext): inline Draft.js and Prosemirror pages (#3854)
• fix: fix(chrome-ext): remove bad assertion
• fix: fix(chrome-ext): remove useless test
• fix: fix(chrome-ext): work within Gutenberg <iframe />s (#3702)
• fix: fix(core): add "understand" to the irregular verb list (#4036)
• fix: fix(core): avoid to-too false positives outside adjective contexts (#3883)
• fix: fix(core): disable MoreAdjective by default
• fix: fix(core): do not flag Dickens as a swear (#4031)
• fix: fix(core): don't flag "no thanks to" as a missing refusal comma (#4088)
• fix: fix(core): major issues with SplitWords (#3857)
• fix: fix(core): more adjustments to SplitWords (#3922)
• fix: fix(core): preserve camelCase proper nouns in title case (#3438)
• fix: fix(core): proper-noun coverage for Apple i-products and product phrases (#3436)
• fix: fix(core): remove ans
• fix: fix(core): remove redundant copy of dictionary in FstDictionary (#4030)
• fix: fix(core): replace the reexecute dictionary entry with re-execute (#4042)
• fix: fix(core): stop LetsConfusion flagging quantifiers after let's (#4082)
• …and 280 more

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

Automattic/harper 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.