Skip to content
CAI
Software that uses CAICheck a score

ttscoff/doing

59.1

Adequate · 6 November 2026

32k

lines of production code

Ruby

with TypeScript

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a command-line time-tracking and activity logging tool called 'doing', designed to record and manage 'What Was I Doing' entries via a modular plugin-based architecture. It provides capabilities for adding, filtering, and archiving tasks with natural language date parsing, tag management, and interactive fuzzy-finding selection. The tool supports extensive data portability through a flexible plugin system for importing from sources like Calendar.app and exporting to formats such as CSV, JSON, and HTML.

How it got here

2014 — CLI architecture overhaul and plugin system

9 changes.

The project underwent a major architectural shift, replacing the monolithic CLI with a modular, plugin-based system and restructuring the core library for better configuration and extensibility. This period involved comprehensive refactoring of the codebase, expanded test coverage for task management commands, and the removal of legacy documentation and older package versions.

2016–2021 — Plugin ecosystem and shell integration

15 changes.

The project expanded its core functionality by introducing a modular plugin system for importing and exporting data in various formats, including CSV, JSON, and Day One. Significant effort was directed toward improving the user experience through comprehensive shell completion scripts for multiple environments and the addition of example commands and plugins. The period also saw the establishment of robust testing infrastructure, documentation, and automation for releases and encrypted file handling.

2022 — Modular architecture and CLI enhancements

11 changes.

This period focused on refactoring the core codebase into modular components, splitting monolithic classes in the WWID core, item management, and item models to improve maintainability. It also introduced significant feature additions, including a threaded test runner, a new interactive prompt system with fzf integration, and advanced changelog querying capabilities. Supporting infrastructure was expanded with new string, array, and time utility libraries, alongside Dockerfile updates for standardized testing environments.

Features

Add Dockerfiles for multiple Ruby versions and shell configuration files

New Dockerfiles have been added for Ruby versions 2.6, 2.7, 3.0, and 3.0.1, each configured to install Bundler 2.2.17, essential utilities (less, vim), and custom shell profiles (bash\_profile, inputrc) to enhance the interactive development experience. These containers are set up to run tests via scripts/runtests.sh, providing standardized environments for different Ruby versions.

docker · high confidence

Add fzf helper with build, release, and installation infrastructure

The lib/helpers/fzf directory now includes the full source and configuration for the fzf fuzzy finder, enabling its integration into the project. This addition provides a Makefile and .goreleaser.yml for building and releasing binaries across macOS (including Apple Silicon), Linux, Windows, and BSD, along with an install script that supports downloading pre-built binaries or building from source. It also includes shell key bindings and completion scripts for bash, zsh, and fish, as well as a Vim plugin and documentation (ADVANCED.md, BUILD.md, README.md).

lib/helpers/fzf · high confidence

Add man page documentation for the doing CLI

Added the \doing.1\ man page, along with its Ronn source (\doing.1.ronn\) and HTML output (\doing.1.html\), providing users with comprehensive documentation on the \doing\ command-line tool. The documentation covers global options, available commands (such as \now\, \later\, \done\, and \archive\), configuration via \\~/.doingrc\ (including per-folder configuration and template customization), and details on the TaskPaper-compatible file format used for storing entries.

man · high confidence

Add shell completion scripts for Zsh, Bash, Fish, and TypeScript (Fig)

Users of Zsh, Bash, Fish, and Fig-compatible shells (like iTerm2 or Warp) now receive built-in shell completion scripts for the \doing\ CLI. The \lib/completion\ directory introduces \\_doing.zsh\, \doing.bash\, \doing.fish\, and \doing.ts\, providing auto-completion for subcommands (such as \again\, \resume\, \archive\, \move\, \done\, \grep\, etc.) and their respective flags (like \--section\, \--tag\, \--search\, \--interactive\). This enables tab-completion for commands and arguments, significantly improving the interactive experience for users of these specific shells.

lib/completion · high confidence

Added threaded test runner with parallel execution and colored output

A new \ThreadedTests\ helper class has been added to \lib/helpers\ that allows running test files in parallel using configurable thread counts (defaulting to 8). It provides real-time progress bars for each test file via \tty-progressbar\ and \tty-spinner\, and includes a \ThreadedTestString\ module to highlight test failures and errors with colored formatting in the console output.

lib/helpers · high confidence

Initial repository scaffolding and documentation structure

The repository now includes essential configuration and documentation files to support development and usage. A \.gitignore\ file is added to exclude build artifacts, caches, and environment-specific files. Development tooling is standardized with \.rubocop.yml\ and \.rubocop\_todo.yml\ for code style enforcement, and \.travis.yml\ for CI testing across Ruby 2.6, 2.7, and 3.0. Documentation is restructured with a new \README.md\, \CHANGELOG.md\, \COMMANDS.md\, and \SECURITY.md\, while legacy RDoc files are removed. Additionally, a \doing.ts\ file provides Fig shell completion specifications, and an \example\_plugin.rb\ demonstrates how to create custom export plugins.

(repo-wide) · high confidence

New Wiki Export plugin for styled HTML output

Adds a new example plugin that exports task data into styled HTML pages. The plugin provides HAML templates and CSS to render individual wiki pages with tags, notes, and time intervals, as well as an index page listing tags with counts. Users can trigger the export via the 'wiki' command, and the output includes responsive styling and hover effects for better readability.

_lib/examples/plugins/wiki\export · high confidence

New array helper modules for tag handling, cleanup, and encoding

The \lib/doing/array\ directory now includes four new modules that extend Ruby's Array class with domain-specific utilities. \ArrayTags\ provides methods to convert between plain strings and \@tag\-prefixed strings, as well as highlighting tags for console output. \ArrayCleanup\ adds methods to remove nils, empty strings, whitespace-only strings, and other 'bad' values (like false or negative numbers) from arrays. \ArrayNestedHash\ allows converting an array of keys into a nested hash structure. \Array\ (the main module) includes helpers for forcing UTF-8 encoding and capitalizing the first letter of each element. These changes enhance how the application processes and formats array data, particularly for tag management and data sanitization.

lib/doing/array · high confidence

New example commands for autotagging, scheduling, and wiki generation

Added four new example commands in lib/examples/commands that extend the core tool's capabilities: autotag wraps the tag command to automatically apply tags based on filters and counts; later and todo provide shortcuts to add entries to specific sections ('Later' and 'Todo') with optional editor integration and note-taking; and wiki generates HTML documentation for tags by leveraging the wiki export plugin, writing output to a doing\_wiki directory. These commands serve as both functional utilities and implementation examples for plugin development.

lib/examples/commands · high confidence

New example plugins for importing Capture Thing data, exporting via macOS 'say', and hooking into post-write events

Three new example plugins are now available in lib/examples/plugins. The Capture Thing Import plugin allows users to import entries from a Capture Thing folder by triggering the 'cap' or 'capturething' command, handling deduplication and tag prefixing. The Say Export plugin enables speaking the most recent entry via macOS's 'say' command, supporting custom voices and templates through configuration. The Hooks plugin demonstrates registering post-write and post-entry-added hooks, including an example integration with Day One for entries tagged with a specific trigger.

lib/examples/plugins · high confidence

New export templates for Markdown, Day One, and HAML formats

Added new template files (lib/templates) to support exporting activity data in Markdown, Day One, and HAML formats. The Markdown and Day One templates provide structured lists of items with dates, titles, times, and notes, while the HAML template offers a styled HTML layout with responsive CSS for viewing activity logs.

lib/templates · high confidence

New import plugins for Calendar.app, Timing.app, Doing, and JSON formats

Users can now import task entries from external sources using four new import plugins. The Calendar.app plugin imports events from macOS Calendar into Doing, preserving titles, notes, and due times. The Timing.app plugin imports task data from Timing JSON reports, mapping project names to tags and setting completion times. The Doing plugin allows importing from existing Doing-formatted files, supporting updates to existing items and duplicate detection. The JSON plugin imports entries from Doing's own JSON export format, enabling data restoration or migration. All importers support filtering by search terms, date ranges, and tags, with options to add prefixes, apply autotagging, and prevent overlapping entries.

lib/doing/plugins/import · high confidence

New interactive prompt system with fzf integration

The \lib/doing/prompt\ directory now provides a comprehensive set of terminal interaction capabilities, replacing previous ad-hoc implementations. Users benefit from fuzzy-finding selection menus powered by \fzf\ (which is now automatically installed if missing), multi-line text input with Readline support and tab completion, and robust yes/no questioning. This refactoring standardizes how the application handles user input, ensuring consistent behavior across commands like \doing select\, \doing note\, and \doing list\.

lib/doing/prompt · high confidence

New plugin-based export system with multiple format options

The export functionality has been refactored into a modular plugin system, introducing dedicated export plugins for By Day (grouped daily totals), CSV, Day One (plist), Doing format, HTML, JSON (including a timeline view), Markdown, TaskPaper, and generic templates. Users can now export their task data into these specific formats, with the JSON export supporting both standard JSON and a timeline visualization, and the Day One export allowing import into the Day One journal app.

lib/doing/plugins/export · high confidence

New shell completion generators and release automation scripts

Added new Ruby scripts to generate shell completions for Bash, Fish, and Zsh, which parse the application's help output to provide context-aware tab completion for commands and options. Also introduced a \deploy.rb\ script that automates the release process, including version validation, running parallel tests, generating documentation, updating the wiki, and pushing git tags, all with visual progress feedback.

scripts · high confidence

New shell completion generators for Bash, Zsh, Fish, and Fig

The \lib/doing/completion\ directory now includes dedicated generators for Bash, Zsh, Fish, and Fig (Zsh-compatible) shell completions. These new Ruby classes (\BashCompletions\, \ZshCompletions\, \FishCompletions\, \FigCompletions\) dynamically parse the CLI's help sections and command options to produce accurate, context-aware tab-completion scripts for each supported shell environment, replacing or supplementing previous manual or limited completion logic.

lib/doing/completion · high confidence

New string utility modules for highlighting, tagging, and formatting

The \lib/doing/string\ directory now includes dedicated modules for enhanced string processing. \StringHighlight\ adds ANSI colorization for @tags and search result matching, while \StringTags\ provides robust methods to add, remove, rename, and deduplicate tags in task strings. \StringQuery\ introduces fuzzy search, wildcard support, and phrase/boolean query parsing. Additionally, \StringTransform\ and \StringTruncate\ offer text wrapping, capitalization, pluralization, and flexible truncation strategies, and \StringURL\ converts raw URLs into formatted links for HTML, Markdown, or terminal output.

lib/doing/string · high confidence

New time formatting and parsing library

The \lib/doing/chronify\ library has been introduced to handle time-related operations, providing methods to parse natural language dates and durations (e.g., '1d2h30m', 'yesterday 5:30pm') into time objects, and to format durations into human-readable strings (e.g., '2 years, 3 days') or compact formats (e.g., '2y 3d'). This includes support for converting seconds to days/hours/minutes, expanding date tags in strings, and splitting date ranges.

lib/doing/chronify · high confidence

Removals

Removal of generated RDoc documentation files

The \html/\ directory, which contained the generated RDoc documentation for the \doing\ CLI tool, has been completely removed. This includes the main index, class and module pages (such as \WWID\, \String\, and \Object\), the README, and associated assets like CSS and JavaScript files. Users will no longer have access to the local HTML documentation generated by RDoc 4.1.1.

html · high confidence

Removal of the 'doing' CLI tool

The 'doing' CLI application (version 0.1.1) has been removed from the package. This eliminates the ability to add, list, and manage 'What Was I Doing' reminders via the command line, including commands such as \now\, \recent\, \today\, and \archive\, as well as the underlying library logic for parsing TaskPaper-compatible files and managing user configuration.

pkg, pkg/doing-0.1.1 · high confidence

Architecture

Major CLI architecture overhaul and plugin system introduction

The \bin/doing\ entry point has been completely rewritten to replace the previous monolithic command structure with a modular plugin-based architecture. This change introduces a new plugin system (supporting export plugins), standardized input type normalization (for booleans, case sensitivity, age, order, and tag sorting), and environment-driven logging configuration via variables like \DOING\_LOG\_LEVEL\ and \DOING\_DEBUG\. The CLI now uses \GLI\ with specific help text wrapping and autocomplete settings, and initializes a new \Doing::WWID\ object alongside a dedicated logger, marking a significant shift in how the tool is structured and extended.

bin · high confidence

Refactored WWID core into modular components

The WWID (What Was I Doing) core logic has been split from a single monolithic class into distinct, focused modules: display, editor, filetools, filter, guess, interactive, modify, tags, timers, and utilities. This refactoring improves code organization and maintainability without changing user-facing behavior, as the public API and command-line interface remain unchanged.

lib/doing/wwid · high confidence

Refactored item management into modular sub-classes

The \lib/doing/items\ logic has been reorganized from a single monolithic class into five focused modules: \filter.rb\ (search, tag, and date filtering), \items.rb\ (core collection methods like ID lookup and serialization), \modify.rb\ (item deletion and updates), \sections.rb\ (section creation, deletion, and fuzzy matching), and \util.rb\ (deduplication, diffing, and tag aggregation). This structural change improves maintainability and clarity of the item handling capabilities without altering the external API surface.

lib/doing/items · high confidence

Behavioural changes

API documentation no longer displays source code for methods

The YARD template for method details has been updated to explicitly return nil for the source content. As a result, the generated API documentation will no longer include the raw source code snippets for methods, providing a cleaner view of the documentation without implementation details.

_yard\templates · high confidence

Added file mapping for encrypted build notes

A new mapping configuration file has been added to the .gitsecret paths directory, explicitly associating the 'buildnotes.md' file with the encryption system. This ensures that build notes are automatically encrypted when committed and decrypted when checked out, keeping sensitive build information secure in the repository.

.gitsecret · high confidence

Item model refactored into modular components with ID support

The core item representation has been restructured into separate modules for dates, tags, state, and queries, improving maintainability. Items now include a unique MD5-based identifier (accessible via the \id\ attribute) to support precise tracking and deduplication. The item model also supports multiple sections and provides enhanced search capabilities, including fuzzy matching and case-insensitive search options, allowing users to find entries more flexibly.

lib/doing/item · high confidence

Major codebase restructuring and new CLI capabilities

The \lib/doing\ library has been significantly refactored into a modular architecture, introducing new files for command options (\add\_options.rb\), configuration management (\configuration.rb\), and a hook system (\hooks.rb\). This change adds new user-facing capabilities, including a \--bool\ flag for combining tag filters with AND/OR/NOT logic, a \--template\ flag to override output formats with custom strings, and a \--back\ flag to backdate new entries. It also introduces a new \boolean\_term\_parser.rb\ for advanced query parsing and a \completion.rb\ module to generate shell completion scripts for Zsh, Bash, Fish, and Fig. The refactoring also includes a new \cli\_status.rb\ for improved terminal progress indicators and a \colors.rb\ module for enhanced ANSI color support in templates.

lib/doing · high confidence

Major library refactoring and expanded configuration capabilities

The core library has been significantly restructured, replacing the previous minimal setup with a comprehensive module that includes new configuration resolution, logging, and plugin management. Users benefit from improved configuration handling, including support for dot-separated keypaths and per-project configuration files, as well as enhanced logging capabilities and better integration with external tools via new dependencies like TTY libraries and YAML/JSON support.

lib · high confidence

Modularized command structure with new shell completion and changelog viewer

The CLI commands in bin/commands have been refactored into individual, modular files (e.g., again.rb, archive.rb, changes.rb) to improve maintainability. This change introduces a new \doing changes\ command for viewing version history with interactive and markdown support, and adds \doing completion\ subcommands to generate and install shell completion scripts for zsh, bash, and fish. Additionally, the \doing commands\ command now allows users to enable or disable specific CLI commands via configuration.

bin/commands · high confidence

New changelog querying and filtering capabilities

The changelog tool now supports advanced filtering and search. Users can filter changelog entries by type (changed, new, improved, fixed) using the \--only\ flag, and optionally include a type prefix in the output with \--prefix\. The \changes\ command now supports a \--lookup\ option to find versions relative to a specific version (e.g., \\> 1.0.0\, \prior 2.0.0\), and a \--search\ option to find entries matching a query string. Additionally, versions with no matching changelog entries are no longer shown in the interactive menu.

lib/doing/changelog · high confidence

Rubocop style fixes in Cucumber step definitions and support files

The Cucumber test infrastructure files (step definitions and support/env) have been updated to comply with Rubocop style guidelines. This includes adding frozen\_string\_literal pragmas, adjusting regex syntax in step definitions, and modernizing file path resolution in the support environment setup.

_features/step\definitions, features/support · high confidence

Test coverage

Added test helper utilities for time handling and output mocking; Added test plugins for hooks, export, and import functionality; Expanded test coverage for core task management commands.

Dependencies

Update Ruby dependencies and lockfile for doing gem v2.1.92

The \doing\ gem has been updated to version 2.1.92, introducing a comprehensive refresh of its Ruby dependencies. Runtime dependencies now include \chronic\, \csv\, \deep\_merge\, \haml\, \logger\, \ostruct\, \parslet\, \plist\, \reline\, \safe\yaml\, and various \tty-\\ libraries, while the \gli\ dependency has been bumped to version 2.20. Development dependencies have also been updated to include \rubocop\, \github-markup\, \parallel\_tests\, \redcarpet\, \test-unit\, and \yard\. The \Gemfile\ source has been changed from HTTPS to HTTP, and the \Gemfile.lock\ has been regenerated to reflect these changes.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 59 → 59 (+0.3)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 55 → 55 (+0.0)
  • Architecture 89 → 87 (-1.6)
  • Maturity 65 → 65 (+0.0)
  • Readiness 59 → 59 (+0.0)
  • Security 78 → 73 (-4.7)
  • Accessibility 58 → 60 (+2.3)
  • Performance 71 → 71 (+0.0)

Resolved (9)

  • Ambiguous 'bad' vs 'empty' distinction. remove_bad and remove_empty are distinct, but remove_bad is vague. Does 'bad' mean nil, empty strings, or invalid objects? Without seeing the implementation, the naming remove_bad is less descriptive than remove_empty. If remove_bad includes remove_empty logic, it's redundant. If they are distinct, bad is a poor name.
  • Disclosure policy has no reporting contact
  • Documentation: no installation or build instructions (docs/doc/top-level-namespace.html)
  • Documentation: no project overview (docs/doc/index.html)
  • Documentation: no project overview (docs/doc/top-level-namespace.html)
  • Duplicate functionality across namespaces. Doing.String and Doing.Completion.StringUtils both expose ltrunc and ltrunc!. Additionally, Doing.Completion.StringUtils exposes short_desc which is not present in Doing.String (though Doing.String has short_desc in the list? No, Doing.String has short_desc in the list provided: Method: String.short_desc()). Wait, looking closely: Doing.String has short_desc(). Doing.Completion.StringUtils also has short_desc(). This is a clear duplication of utility methods between a core String extension and a Completion-specific StringUtils class.
  • Inconsistent bang (!) usage semantics. In Ruby, ! usually indicates mutation. deep_freeze and deep_freeze! likely both freeze, but one might be recursive vs shallow or have different side effects. Similarly for thaw. However, deep_thaw and deep_thaw! are present. If deep_freeze is non-mutating (returns new frozen hash) and deep_freeze! is mutating, this is consistent. But if both mutate, the ! is redundant. The same applies to thaw. Without implementation, the presence of both suggests potential confusion if the distinction isn't strictly 'mutating vs returning new'.
  • Inconsistent validation method naming. Most types use good?() for validation, but Doing.String uses valid_id?(). This suggests valid_id? might be specific to ID validation, but given the presence of good? on other String-like or general types, it creates confusion about whether valid_id? is a general validator or a specific one. If it is general, it should be valid? or good?. If it is specific, the name is misleadingly broad compared to good?.
  • Potential overlap in configuration retrieval. fetch and value_for_key both retrieve values from configuration. fetch takes a path and default, while value_for_key takes a keypath. If value_for_key does not support defaults or handles resolution differently, it's a separate concern. However, the naming fetch vs value_for_key is inconsistent with standard Ruby conventions (fetch usually implies raising or defaulting, [] or dig is more common for lookup). If value_for_key is the primary accessor, fetch might be redundant or confusingly named.

New (2)

  • Disclosure policy has no reporting contact (SECURITY.md)
  • Documentation: no build, run or usage example (README.md)

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

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

Survey your own repository

ttscoff/doing 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 69879f12f362b992d79728a40b37056160b6b98c — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.2+preprod-5c4e66d9318b.