PluginBench
Skill
Review
Audit score 70

diffity-resolve-tree

nilbuild/diffity

Resolve code review comments from diffity tree browser by making requested fixes

What is diffity-resolve-tree?

This skill reads open comments left on repository files in the diffity tree browser and resolves them by implementing the requested code changes. Use it when you have pending review comments that need to be addressed through code modifications, documentation updates, or clarifying replies.

  • List all open comment threads with full details including file paths, line numbers, and comment bodies
  • Distinguish between actionable code changes, questions requiring answers, and general summaries
  • Make code changes, refactors, or documentation updates based on comment requests
  • Reply to questions with answers and resolve threads with summaries of changes made
  • Skip non-actionable comments and wait for user responses when appropriate

How to install diffity-resolve-tree

npx skills add https://github.com/nilbuild/diffity --skill diffity-resolve-tree
Prerequisites
  • diffity CLI installed globally (npm install -g diffity)
  • Active diffity tree session running (start with diffity tree command)
Claude Code
Cursor
Windsurf
Cline

How to use diffity-resolve-tree

  1. 1.Run diffity agent list --status open --json to fetch all open comment threads
  2. 2.For each thread, read the comment body and identify the file and line range it references
  3. 3.Examine the full file context to understand what change is being requested
  4. 4.For [question] comments, read the code and reply with an answer using diffity agent reply
  5. 5.For suggestion comments, make the requested code change or documentation update directly
  6. 6.After making changes, resolve the thread with diffity agent resolve and a brief summary
  7. 7.Run diffity agent list again to confirm all applicable threads are resolved

Use cases

Good for
  • Automatically address code review feedback by implementing suggested refactors or improvements
  • Answer inline questions about code by examining the relevant file context and replying with explanations
  • Update documentation based on reviewer comments requesting better docs or clarification
  • Batch-resolve multiple pending review comments across a codebase in one operation
  • Handle both explicit requests and phrased-as-questions suggestions from reviewers
Who it's for
  • Developers managing code review workflows with diffity
  • Teams using diffity tree for collaborative code feedback
  • Individual contributors addressing reviewer comments automatically

diffity-resolve-tree FAQ

What's the difference between [question] comments and suggestions?

[question] comments are explicitly tagged and expect an answer via reply. Suggestions are phrased as questions (e.g., 'should we add X?') but are actionable requests — make the change directly rather than just replying.

Should I resolve general comments (filePath __general__)?

No, skip general comments — they are summaries, not actionable code changes anchored to specific lines.

What if a comment is unclear or ambiguous?

Reply asking for clarification using diffity agent reply with a polite request for more details, then resolve the thread once you understand the intent.

Can I resolve a single thread instead of all open threads?

Yes, pass the thread-id argument (full UUID or 8-char prefix) to resolve only that specific thread.

How do I know when changes are reflected in the browser?

Resolved status appears in the diffity tree browser within 2 seconds via polling — check the browser after running the skill.

Full instructions (SKILL.md)

Source of truth, from nilbuild/diffity.


name: diffity-resolve-tree description: Read open comments from the tree browser and resolve them by making code fixes user-invocable: true

Diffity Resolve Tree Skill

You are reading open comments left on repository files via the diffity tree browser and resolving them by making the requested code changes.

Arguments

  • thread-id (optional): Resolve a specific thread by ID instead of all open threads. Example: /diffity-resolve-tree abc123

CLI Reference

diffity agent list [--status open|resolved|dismissed] [--json]
diffity agent comment --file <path> --line <n> [--end-line <n>] --body "<text>"
diffity agent resolve <id> [--summary "<text>"]
diffity agent dismiss <id> [--reason "<text>"]
diffity agent reply <id> --body "<text>"
  • --file, --line, --body are required for comment
  • --end-line defaults to --line (single-line comment)
  • <id> accepts full UUID or 8-char prefix

Prerequisites

  1. Check that diffity is available: run which diffity. If not found, install it with npm install -g diffity.
  2. Check that a tree session exists: run diffity agent list. If this fails with "No active review session", tell the user to start diffity tree first (e.g. diffity tree).

Instructions

  1. List open comment threads with full details:
    diffity agent list --status open --json
    
    If a thread-id argument was provided, filter to just that thread. The JSON output includes the full comment body, file path, line numbers, and side for each thread.
  2. If there are no open threads, tell the user there's nothing to resolve.
  3. For each open thread: a. Skip general comments (filePath __general__) — these are summaries, not actionable code changes. b. Skip threads where the last comment is an agent reply that asks the user a question and the user hasn't responded yet — the agent is waiting for user input. c. [question] comments (from the user) — read the question, examine the relevant code, and reply with an answer:
    diffity agent reply <thread-id> --body "Your answer here"
    
    Then resolve the thread with a summary of your answer. d. Comments phrased as questions without an explicit [question] tag (e.g. "should we add X?" or "can we rename this?") are suggestions — treat them as actionable requests and make the change. e. Read the comment body from the JSON output and understand what change is requested. The comment is anchored to a specific file and line range — read the full file to understand context:
    • If the comment suggests a code change, refactor, or improvement, make the change.
    • If the comment suggests adding documentation, add or update the relevant docs.
    • If the comment is genuinely unclear, reply asking for clarification:
      diffity agent reply <thread-id> --body "Could you clarify what change you'd like here?"
      
    f. After making the change, resolve the thread with a summary:
    diffity agent resolve <thread-id> --summary "Fixed: <brief description of what was changed>"
    
  4. After resolving all applicable threads, run diffity agent list to confirm status.
  5. Tell the user to check the browser — resolved status will appear within 2 seconds via polling.