.coderabbit.yaml

# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json
language: en-US
tone_instructions: >-
    Be direct and evidence-first. Report only concrete, actionable findings grounded in changed code.
    Prioritize correctness, security, data loss, lifecycle, and regressions; avoid speculative style
    comments and unrelated refactors.

chat:
    allow_non_org_members: false

knowledge_base:
    web_search:
        enabled: true
    learnings:
        scope: local

reviews:
    profile: assertive
    request_changes_workflow: true
    high_level_summary: true
    high_level_summary_in_walkthrough: true
    review_status: true
    review_details: true
    collapse_walkthrough: true
    changed_files_summary: true
    poem: false

    auto_review:
        enabled: false
        drafts: false
        auto_incremental_review: true
        auto_pause_after_reviewed_commits: 0
        labels:
            - "coderabbit-review-active"

    path_filters:
        - "!**/node_modules/**"
        - "!**/dist/**"
        - "!**/out/**"
        - "!**/coverage/**"
        - "!**/.turbo/**"
        - "!apps/vscode-e2e/.vscode-test/**"
        - "!bin/*.vsix"
        - "!webview-ui/**/__screenshots__/**"

    path_instructions:
        - path: "**/*"
          instructions: >-
              Act as an adversarial second-opinion reviewer. Verify PR claims against implementation and
              contracts. Trace changed inputs through normal, boundary, error, cancellation, retry, and
              default paths and their consumers. Seek plausible counterexamples and regressions from removed
              safeguards. Identify assumptions in changed code that depend on facts outside the diff. First
              verify repository conventions, tests, and related implementations. When a potential finding
              depends on external behavior, use web search and prefer official documentation, specifications,
              or upstream repositories. Report only concrete, actionable conflicts or failure modes, citing
              the relevant repository location or external source. Prioritize correctness, security, data loss,
              lifecycle, and test gaps. Do not report generic best practices, unsupported concerns, speculative
              style comments, or unrelated refactors. When changed code introduces a local implementation of a
              cross-cutting concern, check whether it bypasses or duplicates an established repository abstraction
              or nearby convention. Report only a concrete inconsistency with behavioral or maintenance impact,
              and allow intentional deviations.

        - path: "**/*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}"
          instructions: >-
              Check strict typing and exhaustive behavior across normal, boundary, error,
              cancellation, retry, and compatibility paths. Verify promises and errors are handled,
              existing helpers are reused, and new code introduces no `any`, unjustified double
              assertions, floating promises, duplicated helpers, or increased lint suppressions.
              When a refactor adds early-return guards that redirect a subset of inputs to a new
              code path, confirm the old branches for those inputs are removed or unreachable.

        - path: "{**/*.{test,spec}.{ts,tsx,js,jsx},**/__tests__/**}"
          instructions: >-
              Require regression coverage at the lowest valid harness with behavior-focused
              assertions, including relevant negative, error, false/unset, and boundary cases.
              Check cleanup and deterministic async behavior and prefer shared typed test helpers.
              Visible webview changes require a durable Playwright component snapshot; behavior-only
              changes do not.
              Reject weak assertions on values that could take multiple forms: .toBeDefined() or
              .toHaveBeenCalled() alone are not sufficient when the actual type, value, or object
              identity is verifiable. For listener registration and removal, assert the same function
              reference was added and removed (not expect.any(Function)).
              Flag tests that assert in-flight behavior only after the call completes — these cannot
              prove the behavior fires during execution. Check that describe block names match the
              actual subjects of the tests they contain.
              For tests that assert only mock call counts, confirm a corresponding return-value
              assertion exists; a regression that silently returns stale fallback data can satisfy
              a call-count check. For code with fallback behavior, verify both the cold-start case
              (no prior state) and the warm case (prior state exists) are covered, as they exercise
              different branches.

        - path: "apps/vscode-e2e/**"
          instructions: >-
              Reserve end-to-end coverage for behavior that requires the real VS Code host, workspace
              APIs, extension activation, webview messaging, file watchers, or a full workflow. Keep
              detailed protocol, parsing, storage, retry, and edge cases at lower test layers.

        - path: "{packages/types/src/**,webview-ui/src/components/settings/**,src/core/config/**,src/core/webview/**}"
          instructions: >-
              For persisted settings, verify the complete schema/storage/runtime/webview round trip,
              shared default semantics, and focused true plus false/unset tests. SettingsView controls
              must read and update local `cachedState`, include the value in the explicit save payload,
              and receive the persisted value back from extension state.

        - path: "src/**"
          instructions: >-
              Verify extension/webview contracts, cancellation and error propagation, VS Code
              lifecycle correctness, and behavior under retries and partial failure. Check listeners,
              resources, and providers are disposed without stale state or duplicate work.

        - path: "webview-ui/**"
          instructions: >-
              Check React state and effect dependencies, cleanup, accessibility, i18n, and light/dark
              theme behavior. New markup should use Tailwind; add VS Code CSS variables to
              `src/index.css` before Tailwind use. Use Vitest for behavior and Playwright component
              snapshots only for durable visible changes.

        - path: "{src/api/**,src/core/prompts/**,src/core/tools/**,src/services/mcp/**,src/services/destructive-command-guard/**}"
          instructions: >-
              Treat model, provider, MCP, path, command, and tool data as untrusted. Check approval and
              allowlist bypasses, injection and traversal risks, secrets/PII exposure in logs, abort and
              stream behavior, retries, provider compatibility, and enforcement at execution time—not
              only at presentation or planning time.

        - path: "{src/**/{state,history,task,tasks,service,services,cache,caches,worktree,worktrees}/**,packages/**/{state,history,task,tasks,service,services,cache,caches,worktree,worktrees}/**,webview-ui/src/**/{state,history,task,tasks,service,services,cache,caches,worktree,worktrees}/**}"
          instructions: >-
              Check persistence and lifecycle invariants: awaited atomic writes, rollback or explicit
              partial-failure behavior, cross-window state consistency, stale listeners/watchers,
              cancellation, idempotency, and safe restart/resume without lost or duplicated state.
              For async functions that read shared mutable state before an `await` and write it back
              after, verify the captured reference is still valid when the write executes; a concurrent
              mutation during the await can cause a stale snapshot to overwrite a newer state.

        - path: ".github/**"
          instructions: >-
              Require full commit SHA pins, least-privilege permissions, safe expression and shell
              interpolation, and trusted metadata handling. Privileged workflows must never check out,
              execute, install from, or otherwise trust a fork PR head.

        - path: "{AGENTS.md,**/AGENTS.md,CONTRIBUTING.md,.changeset/**,CHANGELOG.md,src/CHANGELOG.md}"
          instructions: >-
              Enforce repository policy: routine PRs must not add changesets or edit changelogs except
              during release preparation. Verify documentation describes real behavior and contracts,
              and deprioritize prose-only nits that do not affect correctness or usability.

    finishing_touches:
        docstrings:
            enabled: false

    pre_merge_checks:
        override_requested_reviewers_only: true
        docstrings:
            mode: off
        title:
            mode: warning
        description:
            mode: warning
        issue_assessment:
            mode: error
        custom_checks:
            - name: Regression evidence
              mode: error
              instructions: >-
                  Fail only when a concrete changed behavior lacks focused coverage at the lowest valid
                  test layer, tests merely mirror implementation, an affected error/negative/unset branch
                  is omitted, or a durable visible UI change lacks its required Playwright component
                  snapshot. Do not demand tests for unchanged behavior, mechanical configuration, or every
                  branch without a plausible regression scenario. Cite the changed behavior and missing
                  evidence.
            - name: Security boundaries
              mode: error
              instructions: >-
                  Fail only when a concrete changed path leaks secrets or PII, trusts or executes
                  unvalidated input, or bypasses approval or allowlist controls. Cite the changed path
                  and a plausible triggering scenario; pass when no such changed path exists.
            - name: Persistence integrity
              mode: error
              instructions: >-
                  Fail only when a concrete changed persistence path can lose or corrupt state because an
                  operation is not awaited, a write is non-atomic, rollback or explicit partial-failure
                  behavior is missing, or a persisted default is not propagated to a consumer. Cite the
                  changed path and a plausible triggering scenario; pass when no such changed path exists.
            - name: Lifecycle resource cleanup
              mode: error
              instructions: >-
                  Fail only when a concrete changed lifecycle path can leak a listener, watcher, provider,
                  timer, task, or other resource, or can duplicate work after cancellation, disposal, or
                  restart. Cite the changed path and a plausible triggering scenario; pass when no such
                  changed path exists.

    tools:
        eslint:
            enabled: true
        github-checks:
            enabled: true
        actionlint:
            enabled: true
        shellcheck:
            enabled: true
        gitleaks:
            enabled: true
        semgrep:
            enabled: true