assist

I overhauled the permission system today. The old monolithic cli-reads permission group got split into separate reads and writes categories, and I added deny rules via cli-hook deny commands so specific patterns can be blocked. Allow and deny rules now merge across tools (Claude Code and any other configured tool), and I fixed a couple of edge cases — normalizing the ./ prefix in allow matchers and supporting entries without the :* suffix.

Backlog items can now be linked to each other, which is useful for tracking related work and dependencies. I also added --dir to backlog commands for operating on backlogs in other directories, and backlog comments now get inlined directly into phase prompts so Claude Code has full context when executing a phase. The draft and bug modes gained edit mode support, and I added a global config option for sync auto-confirm so it stops prompting on every sync.

On the seq command, I added a --from option for filtering by time range and switched historical queries to use /api/data instead of the events endpoint. I also replaced the --json stdin approach with a --file flag for passing structured input, which is cleaner and avoids control character issues.

I spent today polishing the backlog workflow to make it smoother for continuous use. The headline feature is backlog next now loops automatically when items remain, so I can kick off a session and let it chew through multiple backlog items without manual re-invocation. I also added draft and bug launch modes with /next chaining, so after filing a bug or drafting an item the session chains straight into the next piece of work.

Backlog items now support comments and summaries — comments can be added during execution and summaries are saved when an item is marked done, giving better traceability on what was decided and why. Items also auto-commit after backlog add, removing the manual step.

I added a backlog show command for viewing item details, and a few convenience aliases: ls for backlog list and a as a top-level CLI alias for assist. A couple of fixes improved reliability — graceful exit on Ctrl-C during prompts instead of crashing, and fixing summary persistence so it saves on done rather than phase-done.

I built out the backlog orchestration system today — the big addition is phased execution, where backlog items now progress through tracked phases with automatic advancement. Each phase can include manual checks, and sessions auto-kill on phase completion so Claude Code doesn’t wander off-task. A review phase is auto-generated for each item, and items are automatically marked done when their plan completes. I also added a /draft command for creating new backlog items with LLM-assisted questioning.

On the refactoring side, I added assist refactor extract for pulling functions and their private dependencies into new files. Getting the import rewriting right took a few iterations — fixing stale import cleanup, rewriting paths in the destination file, and skipping barrel exports for non-public functions.

I pushed test coverage from roughly nothing to 17.31%, converting existing tests to BDD style (describe/it blocks) and adding new coverage for splitCompound, collectDependencies, resolveImports, and the backlog run completion logic. I also added test-cover and test-review slash commands so Claude Code can incrementally improve coverage during sessions.

The backlog web view got plan progress display, and the CLI picked up several UX improvements: a show command, numbered acceptance criteria, type display in the next list, comments and summaries on items, a -w/--write flag for backlog run/next, and aliases like next for backlog next -w and remove for backlog delete. I also added a /bug command for filing bugs with structured reproduction steps and a coverage command for reporting test coverage metrics.

Added an assist screenshot command that captures a screenshot of a running application window. You pass it a process name like assist screenshot notepad and it grabs the visible window bounds using the DWM extended frame bounds API (which excludes the invisible shadow padding Windows adds), then BitBlts the region from the screen DC into a PNG.

The heavy lifting is in a PowerShell script that gets written to a temp file and executed with -NoProfile -ExecutionPolicy Bypass. It handles DPI awareness, restoring minimised windows, and all the GDI cleanup. The output directory defaults to ./screenshots but is configurable via screenshot.outputDir in the assist config.

I also added a /screenshot slash command so Claude Code can capture windows during debugging sessions — useful for visual verification of UI changes without leaving the conversation.

Continued refining dotnet inspect today. I replaced the separate --ref and --base flags with a single --scope option that accepts all, base:<ref>, or commit:<ref> — defaulting to working copy diff when omitted. This cleaned up the getChangedCsFiles logic considerably, turning what was a pair of loosely-related flags into a proper discriminated union with a parseScope function.

On the filtering side, I added --suppress to hide specific issue type IDs from the command line (merged with any suppression rules already in config), and --only to show exclusively the specified IDs. The --only filter is handy when you’re hunting for a specific category like CommentedCode across a solution without wading through everything else. Both support variadic arguments so you can pass multiple IDs in one go.

I moved all the shell read commands (cat, head, ls, grep, etc.) out of claude/settings.json and into the assist.cli-reads file where they belong. This meant updating findCliRead to support single-word command matching — previously it only matched two-word prefixes like git log, so bare commands like cat or head were falling through. Much cleaner having all the read-command allow-listing in one place.

Added a /raven slash command so Claude Code can interact with RavenDB connections and collections conversationally — listing collections, querying documents, and managing connections without leaving the editor.

The seq query default count went from 50 to 1000, which is a much more useful default for log exploration. It now also warns when results hit the limit so you know to increase --count if needed.

Finally, I added assist roam show-claude-code-icon which forwards Claude Code hook activity to the Roam local API. It reads the Roam API port from the app data directory and POSTs activity events, failing silently if Roam isn’t running.

Big restructure of the .NET inspection tooling today. I replaced the old netframework command group with a unified dotnet namespace, consolidating code inspection, build tree, and dependency commands under one roof. The dotnet inspect command now runs JetBrains InspectCode by default with --swea as opt-in, filters out unreliable .Global rules that were producing false positives, and supports a --base flag to scope inspections to files changed since a given git ref. I also added a --roslyn flag that runs Roslyn-based analysis as an alternative engine, with results filtered to only changed .cs files.

The rate-limit status line segment got smarter — it now colour-codes based on consumption pace rather than just the raw percentage, so the visual signal better reflects whether you’re likely to hit the cap.

The other major addition was assist seq for querying Seq log servers. It reuses the same connection-auth pattern I’d built for RavenDB (which I extracted into a shared createConnectionAuth helper), so you can store named connections and query logs with filters directly from the CLI. I added a /seq Claude command alongside it so Claude Code can search logs during debugging sessions.

Finally, I wired up /inspect as a Claude slash command so code inspections can be triggered conversationally without leaving the editor.

Fixed config loading so assist finds assist.yml when invoked from a subdirectory of the repo. Previously loadConfig only looked in the current working directory, which meant commands failed silently when you were deeper in the tree. Now it walks up to the repo root using a shared findRepoRoot helper that was already in the .NET commands — extracted it to src/shared/ so both paths can reuse it.

Also refined the /review-comments Claude command to group PR comments by thread rather than processing each comment individually. Follow-up comments (like a reviewer endorsing a bot suggestion) are now presented as context alongside the primary actionable comment, and fixed/wontfix is only called once per thread.

Added rate limit visibility to the Claude Code status line. The status line now shows current API rate limit usage, and a follow-up improvement added time-to-reset countdowns so you can see at a glance when limits will refresh. Handy for knowing whether to keep working or take a break when approaching the cap.

Added a status dropdown to the backlog web UI so items can be moved between statuses directly from the detail view. The StatusPicker component shows available statuses and sends updates back to the server, which parses and writes the new status into the item body. This means I can now triage and update backlog items without leaving the browser.

Added a full suite of RavenDB commands. ravendb auth handles authentication via 1Password secret references, ravendb set-connection saves named connection configs (URL, database, secret ref), and ravendb query runs RQL queries against a connection with automatic pagination. There’s also ravendb collections to list collections and ravendb search for full-text search across items. Connections are resolved interactively if not specified, and credentials are fetched from 1Password at runtime.

Extended the Jira integration with a jira view command that prints the issue title and description, complementing the existing jira ac command. Refactored the shared fetch logic into fetchIssue.ts so both commands reuse the same API call. Also updated the Claude instructions so it knows when to use jira view vs jira ac.

Narrowed the CLI hook discovery in permit-cli-reads to only scan files listed in a new assist.cli-reads manifest rather than discovering all readable commands dynamically. This gives more control over which commands get added to the allow list.

Added madge as a verify check for circular dependency detection. Selecting it during verify init installs the package and wires up a verify:madge script. While integrating it I found and fixed a handful of actual circular dependencies — extracted shared types in the backlog web UI components and pulled common logic into a shared.ts module in the restructure planner.

Also added a /jira Claude command so Claude Code can fetch Jira issue context directly, and improved verify init to detect scripts already defined in assist.yml so it doesn’t offer to set up checks that are already configured. The init detection was refactored to pull setup handler registration into its own module and centralise the “install package and add script” pattern via setupVerifyRunEntry.

Added two new refactor rename subcommands powered by ts-morph. refactor rename file moves a TypeScript file and updates all imports across the project, while refactor rename symbol renames a variable, function, class, or type and updates every reference. Both default to dry-run mode showing what would change, with an --apply flag to execute.

Also added madge as an option in verify init for circular dependency detection — selecting it installs the package and wires up a verify:madge script automatically.

Fixed a test that was failing on non-Windows platforms by skipping the MSYS path conversion test when not running on Windows.

Built an RSS news reader into the CLI. news add lets you add feed URLs to your global config, and news web spins up a local web server that fetches all configured feeds, parses both RSS and Atom formats, and renders items in a React UI grouped by date. Each feed gets a consistent color-coded badge, items show favicons and relative timestamps, and excerpts are extracted from descriptions with HTML stripped. Also extracted shared web server utilities into src/shared/web.ts to deduplicate the pattern already used by the backlog web view.

Separately, fixed the prs fixed command to push the commit before resolving the review thread — previously it would resolve the thread with a commit link that didn’t exist on the remote yet. Also suppressed noisy JSON output from gh api calls when resolving PR comment threads.

Added Jira integration with two new commands. jira auth handles authentication via API token, prompting for site, email, and token then persisting the site and email to ~/.assist/jira.json for future use. jira ac fetches and prints acceptance criteria for a given issue key, converting Atlassian Document Format to readable markdown text with support for headings, ordered and bullet lists, and inline code.

Also fixed gh api calls in the PR comment resolution flow to suppress JSON output that was being dumped to the terminal by piping stdout to pipe instead of inherit.

Added a devlog repos command that scans all tracked repositories and displays a summary table of their devlog status — showing the last version, date, and how many unversioned days remain. Handy for quickly seeing which repos have pending devlog entries.

Moved the devlog skip days configuration out of each individual repo’s assist.yml and into the blog repo’s config instead. Skip days are now keyed by repo name in a single central location, which keeps per-repo configs cleaner and makes the skip list easier to manage. Updated devlog skip, devlog list, and devlog next to read from the new location.

Added a netframework deps command that builds and prints a dependency tree for .NET Framework projects. It finds containing solutions, resolves .csproj references, and displays the tree structure. Useful for understanding project dependencies in legacy codebases.

Enhanced the run command with positional parameter support — run add can now define named parameters that get substituted at runtime, making custom commands more flexible. Also added elapsed time printing after each run completes, so you can see how long commands take.

Fixed npm install detection to work through fnm and nvm version manager wrappers.

Extended the CLI hook to handle compound commands — piped commands, && chains, and semicolons are now split and each part checked individually against the approved reads list. This means Claude Code can auto-approve things like git status && git diff without needing each compound form explicitly listed. Consolidated the cli-hook subcommands into a cleaner structure.

Also switched the cli-reads lookup to pure JavaScript to avoid shell overhead on each hook invocation, and made assist update run npm install after pulling to ensure dependencies stay in sync.

Built a CLI permissions system that auto-discovers read-only commands from installed CLIs and generates a flat file (assist.cli-reads) of safe-to-approve patterns. The cli-discover command parses help output from CLIs to classify subcommands as read-only or mutating, and cli-hook integrates with Claude Code’s hook system to auto-approve matching commands. This replaces the manually-maintained allow list in settings.json for read operations.

Also auto-approves read-only gh api calls by inspecting the HTTP method and endpoint, added a /sync slash command for syncing settings from the terminal, and fixed commit argument ordering to put the message first.

Improved the commit command to accept a message directly without requiring file arguments, and updated new to automatically add VS Code configuration when scaffolding a Vite project. Fixed shell argument escaping across the tool and added a --verbose flag for debugging.

Several fixes around packaging and release — made voice runtime dependencies optional so they don’t block installation, synced package-lock.json with the new ast alias, and ensured the lock file gets committed during releases. Also fixed isGitRepo to check the exact git root rather than matching parent directories, and used a shorter notification sound for WSL.

Switched the voice daemon’s speech-to-text to use GPU inference for faster transcription, and fixed silence detection to properly reset after smart turn checks. Also added word-level diffing for more accurate voice typing output.

Added radon-based complexity checks for Python projects — both cyclomatic complexity and maintainability index at the file level. This complements the existing TypeScript complexity checks and runs as part of verify.

Introduced ast as a short alias for the assist command. Added context percentage colouring to the status line, made commit accept explicit file lists and status output, paginated the GitHub API in list-comments to handle large PRs, and hid completed items from backlog list by default.

Built a voice interaction daemon that listens for a wake word and transcribes speech to type into Claude Code. The daemon runs as a background process with configurable wake and submit words — say the wake word to start listening, then the submit word to send. Iterated on it throughout the day, fixing word-level diff for more accurate typing, deduplicating daemon code, and routing debug output to a separate console window.

Added prs comment for posting new review comments on PRs, and expanded verify with an all mode and diff-based filters so you can run all checks or only checks relevant to changed files. Also added run environment support and a no-venv verification check for Python projects.

Spent the day polishing the backlog web UI. Migrated the forms to Base UI components and switched the styling to Tailwind for a cleaner look. Added a completed items toggle, a delete command, and story/bug type categorisation. The web UI now opens the browser automatically and is the default when running assist backlog with no arguments.

On the CLI side, added verify list and run list commands so you can see what verification steps and run configs are available without actually running them. Also added hardcoded-colors to the ignore config for projects that need to opt out of colour literal checks.

Built a web frontend for the backlog command using React. Running assist backlog web spins up a local server that serves a single-page app for managing backlog items — viewing, creating, and editing items with descriptions and acceptance criteria. The UI is bundled with tsup and served inline via an HTML template, keeping it self-contained without needing a separate dev server.

Also fixed config saving to preserve unknown keys, so custom or future config values aren’t silently dropped when writing back to assist.yml.

Updated verify to resolve its entries from both run configs and package scripts, so custom verification steps defined via assist run add are picked up automatically alongside the standard checks. Also made run add generate a command file when adding a new run config, giving each custom command a proper home rather than just an inline script.

Added /journal and /standup Claude commands. The journal command appends an entry summarising recent work, decisions, and notable observations. The standup command reads recent journal entries and generates a standup update. Both are Claude commands rather than CLI commands since they rely on Claude’s context and summarisation abilities.

Also fixed the commit config to include proper defaults so it works correctly even when not explicitly configured.

Added a roam auth command that handles the full OAuth authorization flow for Roam Research. It prompts for client credentials, opens the browser for authorization, spins up a local callback server to receive the auth code, and exchanges it for an access token. The token gets stored in the config for use by future Roam commands.

Also added a few more git commands (git status, git grep, git log) to the permissions allow list so Claude Code can use them without prompting.

Added a skip option to the /review-comments Claude command so individual comments can be passed over without needing to reply or resolve them. This is useful for comments that need more thought or aren’t actionable yet.

Also added an assist update command for self-updating the tool via npm, and fixed the permissions allow list for complexity commands.

Added a backlog command for managing a simple task backlog — items can be listed (with a verbose flag for descriptions), added with an editor for longer descriptions, and picked off with /next-backlog-item which selects and starts implementing the next item. This gives a lightweight way to track what needs doing without leaving the terminal.

Built an assist new command that scaffolds a new project — sets up a Vite React TypeScript template, initialises git, and gets everything ready to go. Also added tsup support to vscode init for projects using that bundler, and wired maintainability checks into verify init so new projects get code quality gates from the start.

Continued the maintainability-driven restructuring from yesterday, breaking apart more modules across the codebase — computeRewrites, planFileMoves, parseVtt, displayPaginated, and others were split into focused sub-modules. This was another round of using the restructure command on the codebase itself.

Added a default action to the complexity command so running it without arguments gives useful output immediately. Also added SHA validation to prs fixed to match what wontfix already had, and allowed gh pr view and gh pr diff in the permissions allow list. Improved the maintainability error message to be clearer about what needs attention.

Added a refactor restructure command that analyses import graphs, clusters tightly-coupled files, and generates a plan to reorganise them into cohesive directories. It builds an import graph, clusters files by coupling, computes file moves, and can execute the plan — all without needing AI assistance. Also exposed it as a /restructure Claude command for interactive use.

Then I ate my own dogfood and used it to restructure the assist codebase itself. Large modules like complexity/shared.ts, prs/listComments.ts, transcript/parseVtt.ts, and index.ts were broken apart into focused sub-modules. The main index.ts went from a monolithic command registration file to thin register*.ts files. This brought the codebase maintainability scores above 60 across the board.

Also added a readme CLI command (previously only a Claude command) and capped wontfix reasons to 15 words.

Expanded the complexity command into a proper verification step. The maintainability index can now run as part of verify, failing the build when files drop below a configurable threshold. When a file fails, it includes an explanation of what the maintainability index measures and what’s dragging the score down, which makes the output actionable rather than just a number.

Added complexity.ignore to the config schema so specific files or patterns can be excluded from checks. Also added support for custom lint verify scripts, letting projects define their own lint commands alongside the built-in ones.

Added a config command backed by Zod schema validation. It lists current configuration values with their defaults applied from the schema, so you can see effective values even when they’re not explicitly set. This builds on the existing assist.yml config file and loadConfig() infrastructure.

Introduced a sync subcommand that copies user-level Claude instructions (CLAUDE.md) to the home directory, keeping project-specific settings in sync across workspaces. Also made notify configurable via the new config system with a default-enabled flag.

Fixed packaging issues where Claude commands weren’t being included in the published package, and added type checking to the CI release pipeline to catch build errors earlier.

Added a suite of transcript commands for processing meeting recordings. The transcript format command parses VTT subtitle files into clean markdown transcripts, handling speaker identification and timestamp formatting. The transcript summarise command uses a staged workflow — it first generates a summary via a Claude command, then saves it alongside the original transcript with a link back to the source file. Iterated on the summary output a few times to get the file paths and links right, including URL encoding and using relative paths.

Also improved the PR review workflow — prs list-comments now includes resolved comments (marked as such) for better context, and wontfix validates commit SHAs before responding. Updated the /review-comments Claude command docs to enforce backticks for code references and clarify the markdown link syntax.

Continued building out the PR review workflow with prs fixed and prs wontfix commands. These replace the earlier reply and resolve commands with more opinionated actions — fixed replies with a message about the fix and resolves the thread, while wontfix explains why the comment won’t be addressed and resolves it. This better matches how I actually respond to review feedback.

Improved the list-comments flow to handle the case where all review threads are already resolved — it now drops the comment cache and prints a clear message instead of showing an empty list.

Built out the PR review workflow with prs reply and prs resolve commands, so I can respond to review comments and mark threads as resolved directly from the CLI. Updated the /review-comments Claude command to take advantage of these — it now filters out already-resolved threads so Claude only focuses on what still needs attention.

Added a /readme Claude command that checks README.md for missing command documentation. This ties into the project convention of keeping the README in sync whenever CLI or Claude commands change.

Small fix to use 7-character SHAs in commit output for consistency, and enforced LF line endings across the repo via .gitattributes.

Added a complexity command that calculates maintainability metrics for source files — cyclomatic complexity, Halstead measures, and SLOC — giving a quick code health overview without needing external tools.

Built out PR review comment support in two parts. First, a prs comments subcommand that fetches and displays review comments from GitHub PRs in a human-readable format, with proper error handling for missing repos. Second, a /review-comments Claude command that lets Claude Code process PR review comments interactively. Iterated on the comments output to handle Windows path compatibility and 404s gracefully.

Tightened up the codebase with a lint rule to catch .js import extensions in TypeScript files and renamed source files to follow camelCase conventions enforced by Biome. Fixed knip to properly fail verification on config hints instead of silently passing. Removed the unused enable-ralph command and updated the README.

Added a notify command that integrates with Claude Code’s notification hooks to show desktop notifications when Claude needs attention. It handles different notification types like permission prompts and idle prompts, displaying the project name and relevant message. The command works across platforms - using node-notifier on native systems and calling SnoreToast directly from WSL to show Windows notifications. Fixed an issue on macOS where notifications would disappear immediately by setting a long timeout and enabling wait mode.

Improved the devlog next command to read the version directly from package.json at the last commit when commit.conventional is enabled. Previously it relied on parsing devlog entries to determine the current version, but for repos using semantic-release the version is already tracked in package.json. This makes the version suggestions more accurate for projects that don’t have a devlog entry for every release.

A productive day with several new features for the assist CLI.

Added a status-line command that formats Claude Code’s status JSON into a readable status line showing the model name, token counts (input/output), and context window usage percentage. This integrates with Claude Code’s custom status line feature.

Enhanced the commit command with conventional commit validation. When commit.conventional is enabled in assist.yml, messages must follow the standard format like feat: add feature or fix(scope): fix bug. Also added configurable pull and push options so commits can automatically sync with the remote.

The deploy command gained a redirect subcommand that injects a trailing slash redirect script into index.html, useful for static site deployments. The deploy init command now prompts to install netlify-cli if it’s missing.

Updated VS Code settings generation to configure Biome’s organize imports on save, replacing the per-language formatter overrides with a single global config.

Fixed a WSL compatibility issue where enquirer’s confirm prompts displayed incorrectly. Replaced the Unicode symbols with ASCII [x] and [ ] markers. Also extracted the ESLint removal logic into a shared utility so both lint init and new commands can use it.

Added a new run command that executes configured commands stored in assist.yml. You can define named commands with optional default arguments, then invoke them with assist run <name>. Any extra arguments passed get appended to the configured ones. There’s also assist run add to quickly register new configurations without editing the YAML manually.

The config loader now checks .claude/assist.yml first before falling back to assist.yml in the project root, allowing the configuration to live alongside other Claude-related settings.

Fixed an issue where run add would mangle arguments containing colons or other special characters due to Commander’s argument parsing. The fix bypasses Commander and parses process.argv directly to preserve the original argument values.

Added a new prs command that lists pull requests for the current repository using the GitHub CLI. It supports filtering by state (--open or --closed) and paginates results with interactive navigation when there are more than 10 PRs. Each entry shows the PR number, title, author, status with date, and changed file count.

Also set up semantic-release for automated npm publishing. When commits land on main, the release workflow analyzes commit messages and automatically bumps the version, updates the changelog, publishes to npm, and creates a GitHub release. The package is now published as @staff0rd/assist with public access. Added conventional commit guidance to CLAUDE.md to ensure proper version bumping.

Fixed a bug in the lint init command where biome overrides weren’t being copied to the target project’s biome.json. Previously only the linter rules were propagated, but now any overrides defined in the template (like allowing constants.ts files to use kebab-case naming) get copied over too.

Also tweaked the verify:test script to use vitest’s dot reporter, which only shows output for failing tests rather than listing every test file. Makes the verify output much cleaner when everything passes.

Did some internal refactoring as well, extracting each verify setup function into its own file to keep things organized.

Made several small improvements to the devlog workflow. Added support for overriding the project name in assist.yml via devlog.name, useful when the git repo name doesn’t match what I want in devlog entries.

Also refined the Claude Code command prompt: improved tag selection guidance to prefer existing tags over creating new ones, added a diff check before skipping entries to ensure nothing meaningful gets missed, and reordered the tag fetch to happen later in the workflow.

Added a new command for scaffolding fresh projects. It sets up the basic structure and automatically runs initialization commands to get a project ready to go. Also added vite base configuration to new projects so they’re ready for building out of the box.

Created two new init commands: lint init sets up biome with my preferred linting configuration, and deploy init adds a GitHub Actions workflow for automated builds and deployments. The new project command chains these together so a freshly created project has linting and CI/CD configured from the start.

Spent the day on a significant refactoring pass. Extracted large modules into smaller, focused files - the verify init command alone went from a monolithic 377 lines down to several purpose-built modules like detectExistingSetup, setupKnip, and installPackage. Did the same for devlog, refactor, and vscode commands.

Added filename convention enforcement via biome, requiring files to use either camelCase or be named index.ts. This prompted renaming several files like devlog.ts → index.ts and fileNameCheck.ts → runFileNameCheck.ts.

Also improved jscpd integration with quieter output and detection of outdated configurations, plus deduplicated package.json reading logic into a shared utility.

Enhanced the refactor check command to automatically run any verify:* scripts from package.json before reporting results. This catches issues that static analysis might miss by running the project’s actual verification suite. The verify scripts run quietly in the background and only show output on failure.

Also added devlog as a Claude Code skill for easier access, and updated documentation.

Added a suite of new initialization and verification commands today. The main addition is vscode init, which sets up VS Code configuration for a project. I also created a general init command framework to organize these setup utilities.

On the verification side, I built verify hardcoded-colors to detect hardcoded color values in code (with example fixes), and significantly improved verify init. The init verification now properly handles package installation, supports vitest for testing, and works with vite-only builds that don’t use a separate build script.

Continued refining the devlog workflow today. Added a --reverse option to devlog diff so I can view changes in chronological order instead of reverse-chronological, which is more natural when reviewing a sequence of work.

Extended the config system with a skip day feature and git permissions, making it easier to manage which dates get skipped and controlling git operations. Also updated the README with documentation for all the new devlog commands.

Built out a comprehensive devlog command system today. The main feature is devlog next, which shows commits since the last versioned devlog entry and suggests the next patch and minor version numbers. This makes it easy to see what needs documenting and pick the right version bump.

Added devlog skip for marking dates as intentionally skipped (trivial changes that don’t warrant an entry), and devlog diff for reviewing changes with filtering options like --since and --verbose. The diff command also shows devlog status per date so I can see at a glance what’s been documented.

Made several supporting improvements: the sync command now shows line-by-line diffs when copying settings, verify got a --timer option for performance tracking, and I added verify/commit to the global permissions list so they run without confirmation prompts.

Also did some internal cleanup, extracting the devlog functionality into separate modules and adding VSCode settings for biome.

Fixed an issue with the verify command where it would fail to find the package.json file when running from a subdirectory of the project. The command now walks up the directory tree to locate the nearest package.json, matching the behavior users expect when working in nested folders.

Added a --max-lines option to the refactor check command, making the file length threshold configurable rather than hardcoded. This lets me adjust the limit based on project needs or temporarily raise it when I’m not ready to split a file yet.

Also updated the README to better clarify what the tool does.

Added git filter options to the refactor check command. The new --modified, --staged, and --unstaged flags let me focus the check on files I’m currently working on rather than scanning the entire codebase. This makes the command much more useful during active development when I only care about files I’ve touched.

Also removed the unused refactor check next subcommand that showed the single largest violation - the main check command with sorting already handles this use case well enough.

Spent the day polishing the refactor command. Fixed stderr handling in the verify command so errors don’t clutter the output, and made the refactor ignore system use the maxLines setting properly.

Added a new static import linting check to catch cases where dynamic imports could be converted to static ones. Also introduced a refactor next subcommand that shows just the next violation to fix, making it easier to work through issues one at a time.

Did some cleanup on the violation output, moving extraction tips inline and creating a shared logViolations helper to reduce duplication. Test files are now excluded from refactor checks since they often have legitimate reasons for patterns we’d normally flag.

Started building a personal CLI tool called assist to streamline my development workflow. The core features include a commit helper that stages and commits with AI-generated messages, a sync command for updating global commands and settings, and a verify command that runs all project checks in parallel.

Added code quality tooling with lint and refactor commands. The refactor command runs various checks (unused exports, file naming conventions, etc.) and supports pattern filtering for targeted analysis. There’s also an ignore mechanism for suppressing false positives.

Switched from plain tsc to tsup for bundling, which should make the CLI easier to distribute. Wrote up documentation including installation instructions and a CLAUDE.md for AI context.