feat(reactions): add support for fetch reactions for PR comments and react command for set reaction

[fixcik]

Summary by CodeRabbit

• New Features

  • CLI "react" command for single or batch reactions (text or emoji); reactions shown with comments in outputs.
  • Per-section pagination caching with --cache-ttl and --no-cache controls.

• Improvements

  • Thread filtering now supports line ranges.
  • Plain/text output enhanced to render reactions and PR additions/deletions totals.

• Tests

  • Added comprehensive tests covering reactions, queries, formatting, and pagination.

• Documentation

  • Several doc/guide files removed.

[coderabbitai]

📝 Walkthrough

Walkthrough

Adds a new "react" CLI command and reaction support (utils, GraphQL mutation, tests), introduces TTL pagination caching and cursorCache propagation, enhances data fetching and plain/text output to include reactionGroups and PR file stats, extends filtering for line ranges and nitpick ID matching, and deletes several documentation files.

Changes

Cohort / File(s)	Summary
CLI & Command src/cli.ts, src/commands/react.ts, src/commands/react.test.ts	Adds react subcommand parsing, wiring to runReactCommand, --no-cache/--cache-ttl options, and comprehensive unit tests for normalization, batching, success/failure, and exit behavior.
Reaction Utilities & GraphQL src/utils/reactions.ts, src/utils/reactions.test.ts, src/github/mutations.ts, src/github/mutations.test.ts, src/github/apiTypes.ts	New reaction utilities (format, normalize, emoji maps, detection), ADD_REACTION GraphQL mutation, mutation response typing, and tests validating mutation string and reaction utilities.
Fetcher & Caching src/github/fetcher.ts, src/types.ts, src/types.test.ts	Implements TTL-aware pagination cache, fetchAllPagesWithCache and FetchPagesResult, pagination cache types, and Args extensions (noCache, cacheTtl) with corresponding tests.
Data Fetching & State src/core/dataFetcher.ts, src/index.ts, src/state/manager.ts	Propagates cursorCache and cacheTtl through PR fetchers, per-section fetch caches, returns updatedCursorCache, computes PR totalAdditions/totalDeletions from files, and ensures state.cursorCache initialization.
Queries & Thread Processing src/github/queries.ts, src/github/queries.test.ts, src/core/threadProcessor.ts	Embeds reactionGroups fragment into THREADS and THREAD_COMMENTS queries and conditionally includes reactionGroups in processed comment payloads; adds tests asserting reaction fields in queries.
Output Formatting src/output/plainFormatter.ts, src/output/plainFormatter.test.ts, src/output/plainFormatter-suggestion.test.ts, src/output/formatter.ts, src/output/formatter.test.ts, src/output/formatter.test.ts	Exports formatReactionGroups, integrates reaction groups into plain formatter (emoji support, up-to-3 reactors, "and N more"), updates formatter PR metadata to include totals, adjusts many formatting internals and tests.
Filtering & Parsing src/core/threadFilter.ts, src/core/nitpickFilter.ts, src/parsers/comments.ts, src/parsers/comments.test.ts	Adds line-range-aware thread filtering, filterNitpicksById (ID or path:line/range matching), and a parser rule to remove "Learnings used" detail blocks with tests.
Batch Reporting & Tests src/commands/react.test.ts, other tests...*	Extensive tests for batch behavior, partial failures, GraphQL error mapping, and reporting; uses existing batch helpers.
Types & API src/github/apiTypes.ts, src/types.ts, src/output/formatter.ts	Adds AddReactionMutationData and Reactor/ReactionGroup types, extends PR metadata with additions/deletions and output PR meta fields.
Docs Removed / Updated CLAUDE.md, EXAMPLES.md, CHANGELOG.md, CHEATSHEET.md, CONTRIBUTING.md, PROJECT_SUMMARY.md, QUICKSTART.md, docs/plans/..., README.md	Deletes multiple documentation files and a design plan; README gains a "React Command" section describing usage and supported reactions.
Misc / Config .gitignore	Adds .claude/ pattern to ignore local AI plan files.

Sequence Diagram

sequenceDiagram
    actor User
    participant CLI as CLI Parser
    participant React as React Command
    participant Batch as Batch Context
    participant GitHub as GitHub API
    participant Reporter as Result Reporter

    User->>CLI: react THUMBS_UP <id1> <id2>
    CLI->>React: runReactCommand([id1, id2], "THUMBS_UP")
    React->>React: normalizeReaction("THUMBS_UP")
    React->>Batch: prepareBatchCommandContext(ids)
    Batch-->>React: validated IDs
    React->>GitHub: ADD_REACTION_MUTATION(id1, THUMBS_UP)
    alt Success
        GitHub-->>React: {addReaction: {reaction: {id, content}, subject: {id}}}
        React->>React: Record success + log
    else Already Reacted / NotFound / Error
        GitHub-->>React: Error
        React->>React: Map to friendly error + record failure
    end
    React->>GitHub: ADD_REACTION_MUTATION(id2, THUMBS_UP)
    React->>Reporter: reportBatchResults(successes, failures)
    Reporter->>User: Output summary (X succeeded, Y failed)
    React->>User: Exit with status 0/1

Loading

Estimated Code Review Effort

🎯 4 (Complex) | ⏱️ ~50 minutes

Possibly Related PRs

• feat: add mark/reply/resolve commands and inline image support #1 — Adds the batch command framework and helpers (prepareBatchCommandContext, reportBatchResults, runGhMutation) reused by the new react command and mutation execution.

Poem

🐰 I hopped through threads to leave a cheer,

Thumbs and smiles for code I peer.
With caches, types, and emoji bright,
I sprinkle reactions, soft and light.
Praise the PRs — the reviews delight! ✨👍

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 57.14% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The PR title accurately describes the main changes: adding support for fetching reactions from PR comments and implementing a new react command to set reactions.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch feature/reactions

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 4

🤖 Fix all issues with AI agents

In `@docs/plans/2026-02-05-reactions-implementation.md`:
- Around line 1088-1104: The markdown block under the "Add reaction to comment"
section uses triple-backtick fences that contain an inner triple-backtick code
block, which triggers markdownlint MD040; update the outer fence to a longer
fence (e.g., change the opening ```markdown to ````markdown and the closing ```
to ````) so the inner ```bash block is not treated as closing the outer fence,
keeping the same content and examples (the GH CLI examples and supported
reactions list) intact.

In `@src/commands/react.test.ts`:
- Around line 9-20: Add unit tests covering the runReactCommand function: write
tests for a successful reaction flow, input validation failures, and mutation
errors by mocking runGhMutation with vitest-mock-extended; specifically, create
a mock for runGhMutation to return successful mutation results for the success
case and throw or return error payloads for mutation-failure cases, and assert
runReactCommand handles batches and error messages correctly (also include tests
asserting normalizeReaction behavior indirectly via runReactCommand validation).
Ensure tests use vitest-mock-extended for type-safe mocks of runGhMutation and
assert expected outputs/errors from runReactCommand.

In `@src/github/apiTypes.ts`:
- Around line 79-89: The AddReactionMutationData type declares addReaction as
required but GraphQL payloads are nullable and react.ts already uses optional
chaining; update the AddReactionMutationData interface so addReaction is
optional (change addReaction to addReaction?: { ... }) and make the nested
fields optional as well (reaction?: { id?: string; content?: string } and
subject?: { id?: string }) to accurately reflect nullable mutation responses;
adjust any imports/usages if the type change surfaces new TypeScript errors.

In `@src/output/plainFormatter.ts`:
- Around line 25-35: formatReactionGroups currently hardcodes two leading spaces
causing reply reactions to be outdented; change its signature to accept an
indent parameter (e.g., commentIndent: string = '  ') instead of using the
hardcoded "  ", replace the leading spaces in the return mapping with that
commentIndent, and propagate this new parameter to all callers (including the
other occurrence noted) so they pass the correct nesting indent; keep a default
value to preserve existing behavior when callers are not yet updated and ensure
formatReaction is still used to build the icon.

🧹 Nitpick comments (4)

src/utils/reactions.ts (1)

53-61: Trim input and return ReactionType for stronger typing.

This improves UX for stray whitespace and tightens the contract for callers.

♻️ Suggested change

-export function normalizeReaction(input: string): string {
-  const upper = input.toUpperCase();
+export function normalizeReaction(input: string): ReactionType {
+  const normalized = input.trim();
+  const upper = normalized.toUpperCase();
   if (VALID_REACTIONS.includes(upper as ReactionType)) {
     return upper;
   }
-  if (EMOJI_TO_REACTION[input]) {
-    return EMOJI_TO_REACTION[input];
+  if (EMOJI_TO_REACTION[normalized]) {
+    return EMOJI_TO_REACTION[normalized] as ReactionType;
   }
   throw new Error(`Invalid reaction: ${input}`);
 }

src/types.test.ts (1)

24-34: Consider typing the comment object for stronger validation.

The test creates a plain object literal without importing or using the ThreadComment type. This means TypeScript won't actually validate that the object conforms to the interface.

💡 Proposed fix to add type annotation

+import type { Reactor, ReactionGroup, ThreadComment } from './types.js';

-  it('should validate ThreadComment with optional reactionGroups', () => {
-    const comment = {
+  it('should validate ThreadComment with optional reactionGroups', () => {
+    const comment: ThreadComment = {
       id: 'IC_test',
       body: 'test comment',
       author: { login: 'user', __typename: 'User' },
       url: 'https://github.com/test',
       createdAt: '2026-02-05T10:00:00Z',
       reactionGroups: []
     };

src/commands/react.ts (1)

27-61: Consider using for...of instead of Array.from().forEach().

Using for...of is more idiomatic and allows for better control flow (e.g., early exit with break if needed in the future).

♻️ Proposed refactor

-  Array.from(context.resolvedIds.entries()).forEach(([shortId, fullId]) => {
+  for (const [shortId, fullId] of context.resolvedIds.entries()) {
     try {
       const mutationResult = runGhMutation<AddReactionMutationData>(
         ADD_REACTION_MUTATION,
         {
           subjectId: fullId,
           content: normalizedReaction
         }
       );

       const reactionId = mutationResult.addReaction?.reaction?.id;
       result.successful.push(shortId);
       console.log(`✓ Added ${normalizedReaction} reaction to comment ${shortId}`);
       if (reactionId) {
         console.log(`   Reaction ID: ${reactionId}`);
       }
     } catch (error: unknown) {
       const errorMessage = error instanceof Error ? error.message : String(error);

       // Provide friendly error messages
       if (errorMessage.includes('already reacted')) {
         result.failed.push({
           id: shortId,
           error: 'You have already reacted with this emoji'
         });
       } else if (errorMessage.includes('Not Found')) {
         result.failed.push({
           id: shortId,
           error: 'Comment not found or you don\'t have access'
         });
       } else {
         result.failed.push({ id: shortId, error: errorMessage });
       }
     }
-  });
+  }

docs/plans/2026-02-05-reactions-design.md (1)

113-133: Add a language specifier to the fenced code block.

The code block for output format examples is missing a language specifier, which triggers a markdown lint warning.

📝 Proposed fix

-```
+```text
 Plain text (with emoji support):
   👍 (3): `@user1`, `@user2`, `@user3`
   ❤️ (1): `@user4`

[coderabbitai]

⚠️ Potential issue | 🟡 Minor

Avoid nested triple‑backtick fences (markdownlint MD040).
The README snippet uses inside amarkdown block, which can terminate the outer fence and trigger MD040. Use a longer outer fence (or indent the inner block).

Proposed fix

-```markdown
+````markdown
 ### Add reaction to comment
 ```bash
 gh-pr-threads react <short_id> <reaction>
 gh-pr-threads react abc123 👍
 gh-pr-threads react abc123 THUMBS_UP

 # Multiple comments
 gh-pr-threads react abc123 def456 ❤️

Supported reactions: 👍 👎 😄 🎉 😕 ❤️ 🚀 👀

Accepts emoji or text format (THUMBS_UP, thumbs_up, 👍).
-```
+````

</details>

<details>
<summary>🧰 Tools</summary>

<details>
<summary>🪛 markdownlint-cli2 (0.20.0)</summary>

[warning] 1104-1104: Fenced code blocks should have a language specified

(MD040, fenced-code-language)

</details>

</details>

<details>
<summary>🤖 Prompt for AI Agents</summary>

In @docs/plans/2026-02-05-reactions-implementation.md around lines 1088 - 1104,
The markdown block under the "Add reaction to comment" section uses
triple-backtick fences that contain an inner triple-backtick code block, which
triggers markdownlint MD040; update the outer fence to a longer fence (e.g.,
change the opening markdown to ````markdown and the closing to ````) so
the inner ```bash block is not treated as closing the outer fence, keeping the
same content and examples (the GH CLI examples and supported reactions list)
intact.

</details>

<!-- fingerprinting:phantom:poseidon:eagle -->

<!-- This is an auto-generated comment by CodeRabbit -->

[coderabbitai]

Actionable comments posted: 1

🤖 Fix all issues with AI agents

In `@CLAUDE.md`:
- Around line 88-94: The Documentation Policy in CLAUDE.md currently forbids
creating new .md files and says git commit messages are the changelog, which
conflicts with the later "Publishing Checklist" that requires CHANGELOG.md;
update CLAUDE.md to reconcile by either allowing a single maintained
CHANGELOG.md (modify the "Documentation Policy" bullets to permit CHANGELOG.md
and describe who updates it and when) or by removing CHANGELOG.md from the
Publishing Checklist and replacing it with the established git-commit-based
changelog process; edit the "Documentation Policy" and the "Publishing
Checklist" sections so they consistently reference the same changelog mechanism
and include a short rule about where to record release notes (e.g., commit
messages vs CHANGELOG.md) and who is responsible for updates.

[coderabbitai]

Actionable comments posted: 1

🤖 Fix all issues with AI agents

In `@src/github/queries.ts`:
- Around line 13-26: The duplicated reactionGroups selection used in
THREADS_QUERY and THREAD_COMMENTS_QUERY should be extracted into a shared
GraphQL fragment: create a constant REACTION_GROUPS_FRAGMENT containing the
fragment definition (fragment ReactionGroupFields on ReactionGroup {
...fields... }) and replace the inline reactionGroups selection in both
THREADS_QUERY and THREAD_COMMENTS_QUERY with the spread ...ReactionGroupFields,
then append or interpolate REACTION_GROUPS_FRAGMENT into the query strings so
both queries include the fragment definition.

🧹 Nitpick comments (1)

src/github/queries.ts (1)

13-26: Consider extracting the reactionGroups selection into a shared fragment.
The same block appears twice, which can drift over time.

♻️ Suggested refactor (GraphQL fragment)

+const REACTION_GROUP_FRAGMENT = `
+  fragment ReactionGroupFields on ReactionGroup {
+    content
+    createdAt
+    viewerHasReacted
+    reactors(first: 10) {
+      totalCount
+      nodes {
+        ... on User { login }
+        ... on Bot { login }
+        ... on Organization { login }
+        ... on Mannequin { login }
+      }
+    }
+  }
+`;
+
 export const THREADS_QUERY = `
   query($owner: String!, $repo: String!, $number: Int!, $after: String) {
@@
               nodes {
                 id body author { login __typename } url createdAt path line
-                reactionGroups {
-                  content
-                  createdAt
-                  viewerHasReacted
-                  reactors(first: 10) {
-                    totalCount
-                    nodes {
-                      ... on User { login }
-                      ... on Bot { login }
-                      ... on Organization { login }
-                      ... on Mannequin { login }
-                    }
-                  }
-                }
+                reactionGroups { ...ReactionGroupFields }
               }
             }
@@
-`;
+  }
+  ${REACTION_GROUP_FRAGMENT}
+`;
@@
 export const THREAD_COMMENTS_QUERY = `
@@
             nodes {
               id body author { login __typename } url createdAt path line
-              reactionGroups {
-                content
-                createdAt
-                viewerHasReacted
-                reactors(first: 10) {
-                  totalCount
-                  nodes {
-                    ... on User { login }
-                    ... on Bot { login }
-                    ... on Organization { login }
-                    ... on Mannequin { login }
-                  }
-                }
-              }
+              reactionGroups { ...ReactionGroupFields }
             }
@@
-`;
+  }
+  ${REACTION_GROUP_FRAGMENT}
+`;

As per coding guidelines, Extract duplicated code into shared utilities.

Also applies to: 99-112

[coderabbitai]

Actionable comments posted: 2

🤖 Fix all issues with AI agents

In `@src/output/plainFormatter.ts`:
- Around line 546-556: The reaction separator block misaligns and is uncolored:
modify the block that checks comment.reactionGroups (the lines that push
`${commentIndent}│`, `...│  ---`, and `${commentIndent}│`) to use the same
two-space quote prefix and per-user coloring as wrapInQuote (i.e. use
`${commentIndent}  ${userColor('│')}` and color the separator text similarly),
and update formatReactionGroups to either accept a color function/author color
parameter or to emit reaction lines prefixed with the same `${commentIndent} 
${userColor('│')}` so reactions vertically align and use the same user color as
the quote bar.
- Around line 46-48: The reaction bar in formatReactionGroups is misaligned with
wrapInQuote because wrapInQuote outputs `${indent}  │  content` (two spaces
before the bar) while formatReactionGroups currently returns `${indent}│ 
${icon} ...` (no spaces). Update the return template in formatReactionGroups
(the line returning `${indent}│  ${icon} ${usersList}${remaining}`) to insert
the same two spaces before the vertical bar so it becomes `${indent}  │  ${icon}
${usersList}${remaining}`, ensuring both functions use the same alignment.

🧹 Nitpick comments (1)

src/output/plainFormatter.test.ts (1)

88-91: Consider adding a test for custom indent parameter.

The tests use the default indent value. Given the indent parameter affects output alignment, adding a test case that verifies custom indent values produce correctly structured output would help catch alignment regressions.

Example test case

it('should respect custom indent parameter', () => {
  const groups: ReactionGroup[] = [
    {
      content: 'THUMBS_UP',
      createdAt: '2026-02-05T10:00:00Z',
      viewerHasReacted: false,
      reactors: {
        totalCount: 1,
        nodes: [{ login: 'user1' }]
      }
    }
  ];

  const result = formatReactionGroups(groups, true, '      ');
  
  // Verify the custom indent is applied (6 spaces before the bar)
  expect(result).toMatch(/^      {2}│/);
});

[coderabbitai]

Actionable comments posted: 2

🤖 Fix all issues with AI agents

In `@src/output/plainFormatter.ts`:
- Around line 531-533: The badge text is confusing because it mixes "author" and
"owner"; update the badges construction so that when comment.author === prAuthor
it uses a clear label such as ' (author)' or ' (PR author)' instead of ' (author
owner)'; change the badges variable assignment (used to build authorDisplay) to
reflect the clearer label and ensure authorDisplay =
`@${comment.author}${badges}` continues to work.
- Around line 25-50: The parameter indent in formatReactionGroups is unused
causing lint failure; either (A) apply it when constructing each line in the
returned string inside the nonEmptyGroups.map (prepend indent to the returned
template string so each line begins with the indent) — reference function
formatReactionGroups and the mapping that returns `${icon}
${usersList}${remaining}`, or (B) if indentation isn’t needed now, rename the
parameter to _indent (or prefix it with an underscore) to satisfy the
no-unused-vars rule. Make the change in formatReactionGroups so the declared
parameter is used or clearly marked unused.

[coderabbitai]

Actionable comments posted: 6

🤖 Fix all issues with AI agents

In `@src/core/dataFetcher.ts`:
- Around line 139-150: When short-circuiting (the branch that returns early when
targetThreadId || !shouldFetchFiles) you are currently returning a brand-new
empty cache which wipes out previously stored cursors; instead return the
existing cachedCursors (or updatedCursorCache) so prior pagination state is
preserved. Update the early-return in the files branch (and the analogous
early-returns for reviews/comments) to set cache to cachedCursors (or merge into
updatedCursorCache) and keep hadNewData false and nodes empty; reference the
existing variables cachedCursors and updatedCursorCache to locate and replace
the empty cache construction in those short-circuit branches.
- Around line 80-89: The current reduction over filesResult.nodes sets
totalAdditions/totalDeletions to 0 when files are skipped (e.g., when
shouldFetchFiles is false or targetThreadId is set); update the logic in the
block that builds PRMetadata (the metadata object created from
metadataWithoutFiles) so that when filesResult.nodes is empty because files were
intentionally not fetched you either (A) set totalAdditions and totalDeletions
to undefined / omit those fields on PRMetadata, or (B) perform a separate
GraphQL query to fetch overall additions/deletions and populate
totalAdditions/totalDeletions; change the code that computes
totalAdditions/totalDeletions (currently using filesResult.nodes.reduce) to
first detect the skip condition (inspect shouldFetchFiles and targetThreadId or
filesResult.nodes.length) and then follow option A or B, updating PRMetadata
accordingly (referencing symbols: totalAdditions, totalDeletions,
filesResult.nodes, shouldFetchFiles, targetThreadId, PRMetadata,
metadataWithoutFiles).

In `@src/core/threadFilter.ts`:
- Around line 22-47: The current logic using const [startLine, endLine] =
lineRange.split('-').map(Number) treats missing or invalid end parts (e.g.,
"10-" or "10-foo") as falsy and falls back to single-line behavior; update
parsing to split into raw parts (e.g., const parts = lineRange.split('-')),
parse startPart and endPart separately, validate with Number.isFinite for each
parsed value, and explicitly detect when a dash is present but endPart is
missing/invalid and return false (or treat the whole targetThreadId as
malformed) instead of treating it as a single-line; adjust the subsequent checks
that reference startLine/endLine/thread.line/path/targetThreadId accordingly so
range versus single-line is determined by presence and validity of the endPart
rather than simply truthiness.

In `@src/index.ts`:
- Around line 123-126: The code always writes prData.updatedCursorCache into
state.cursorCache after registerIds; change this to respect the noCache flag by
only assigning state.cursorCache = prData.updatedCursorCache when noCache is
falsy. Locate the block around registerIds(state, processedThreads, allNitpicks)
and the subsequent state.cursorCache update and wrap the assignment in a
conditional that checks the noCache variable so cache writes are skipped when
noCache is true; leave state.updatedAt and registerIds behavior unchanged.

In `@src/output/plainFormatter.ts`:
- Around line 11-18: The constant terminalWidth is using a fallback of 120 which
contradicts the “larger default” used in getTerminalWidth(); update
terminalWidth to match the larger default by either calling the helper (replace
const terminalWidth = process.stdout.columns || 120 with const terminalWidth =
getTerminalWidth()) or change its fallback to 150 so both getTerminalWidth() and
terminalWidth use the same default behavior; locate references to
getTerminalWidth and terminalWidth to ensure consistency.
- Around line 57-58: formatReactionGroups is emitting an extra quote bar because
wrapInQuote already prefixes one; change the returned lines in
formatReactionGroups to emit plain content with indent + 4 spaces (no "│" or
extra bar) so wrapInQuote produces the single quoted bar, and apply the same
change to the other similar return expressions referenced around lines 603-613;
update the return in formatReactionGroups (and the analogous returns) to remove
the "│" character and its surrounding spacing and instead output only indent
followed by four spaces then the icon and usersList/remaining content.

🧹 Nitpick comments (6)

src/utils/reactions.ts (1)

53-62: Consider a type-safe alternative to includes with type assertion.

The VALID_REACTIONS.includes(upper as ReactionType) assertion bypasses TypeScript's type checking. A type guard pattern would be more robust:

🔧 Optional: Type-safe validation

+function isValidReaction(value: string): value is ReactionType {
+  return (VALID_REACTIONS as readonly string[]).includes(value);
+}
+
 export function normalizeReaction(input: string): ReactionType {
   const normalized = input.trim();
   const upper = normalized.toUpperCase();
-  if (VALID_REACTIONS.includes(upper as ReactionType)) {
+  if (isValidReaction(upper)) {
     return upper as ReactionType;
   }

src/state/manager.ts (1)

22-25: Redundant assignment for missing property.

Explicitly assigning undefined to a missing property is unnecessary since accessing a non-existent property already returns undefined. However, if the intent is to ensure the property exists on the object (e.g., for consistent serialization or Object.keys() enumeration), this is acceptable.

// These are equivalent for most purposes:
if (!loaded.cursorCache) {
  loaded.cursorCache = undefined; // Property now exists but is undefined
}
// vs simply not having the property at all

If the goal is just backward compatibility for reading, this code can be removed. If it's for consistent object shape, consider adding a brief comment clarifying the intent.

src/core/nitpickFilter.ts (1)

31-33: Consider validating nitpick line parsing for robustness.

The code validates startLine from targetId (line 26-29) but doesn't validate nitpickStart parsed from nitpick.line. If a nitpick has malformed line data (e.g., non-numeric), the comparison would silently fail to match.

This is low-risk since malformed nitpicks would simply not match, but adding a debug log for NaN nitpick lines could help with troubleshooting:

🔧 Optional: Add debug for malformed nitpick lines

       // Parse nitpick line (may be a range like "13-26" or single line "13")
       const nitpickLine = nitpick.line;
       const [nitpickStart, nitpickEnd] = nitpickLine.split('-').map(Number);
+      
+      if (Number.isNaN(nitpickStart)) {
+        debug(`Skipping nitpick with invalid line format: ${nitpickLine}`);
+        return false;
+      }

       debug(`Checking nitpick: path=${nitpick.path}, line=${nitpickLine} against path=${targetPath}, line=${lineRange}`);

src/output/plainFormatter-suggestion.test.ts (1)

5-35: Avoid re-implementing the mapping logic in the test

This test re-parses the code block and remaps the language inline, so it can still pass if the production mapping changes or is removed. Consider exercising the actual formatter path (or extracting a shared helper) and asserting the mapped language there.

src/index.ts (1)

133-138: Use a Set to avoid O(n²) filtering

some inside filter is quadratic for large nitpick lists. Precompute a Set of IDs to keep this linear.

Proposed refactor

-  const botSummariesToDisplay = targetThreadId && nitpicksToDisplay.length > 0 && botSummaries.length > 0
+  const nitpickIdSet = new Set(nitpicksToDisplay.map(n => n.id));
+  const botSummariesToDisplay = targetThreadId && nitpickIdSet.size > 0 && botSummaries.length > 0
     ? botSummaries.map(summary => ({
         ...summary,
-        nitpicks: summary.nitpicks?.filter(n => nitpicksToDisplay.some(fn => fn.id === n.id))
+        nitpicks: summary.nitpicks?.filter(n => nitpickIdSet.has(n.id))
       })).filter(summary => summary.nitpicks && summary.nitpicks.length > 0)
     : botSummaries;

src/output/plainFormatter.ts (1)

267-268: Use options objects for 4+ parameters.

formatSuggestionBlock (Line 267), formatDetailCodeBlock (Line 438), and formatThread (Line 561) exceed 3 params. Please convert these to options objects for readability and consistency. As per coding guidelines: Use options objects for functions with 4+ parameters.

♻️ Example refactor (formatSuggestionBlock)

+interface FormatSuggestionBlockOptions {
+  code: string;
+  restText: string;
+  indent: string;
+  language?: string;
+}
+
-function formatSuggestionBlock(code: string, restText: string, indent: string, language: string = 'typescript'): string[] {
+function formatSuggestionBlock({
+  code,
+  restText,
+  indent,
+  language = 'typescript'
+}: FormatSuggestionBlockOptions): string[] {
   const lines: string[] = [];
   const bar = colors.dim('│');
@@
-    lines.push(...formatSuggestionBlock(code, restText, indent, language));
+    lines.push(...formatSuggestionBlock({ code, restText, indent, language }));