CodeQL / Analyze (actions) (push) Has been cancelled
Build and Test Go Project / build (macos-latest) (push) Has been cancelled
Build and Test Go Project / build (ubuntu-latest) (push) Has been cancelled
Build and Test Go Project / build (windows-latest) (push) Has been cancelled
When searching for a symbol like 'RegisterRoutes', if no exact match
is found, try suffix matching against receiver-qualified names like
'(*Handler).RegisterRoutes'. Returns the match only when unambiguous
(exactly one suffix match).
Error messages now suggest the closest match when a suffix match exists
but wasn't used (e.g., when there are multiple types with the same
method name).
Updated the symbol parameter description to document the receiver
prefix format and note that bare names work when unambiguous.
Multi-var/const blocks now extract all declared names from var_spec_list
children (e.g., 'globalMap, oldRegexp' instead of '_var_declaration_19').
For >3 names, shows first two plus count.
Var/const blocks are keyed by position (like imports) so adding/removing
a variable shows as 'modified' with inline diff rather than remove+add.
When name extraction returns empty, falls back to showing the first line
of the declaration text instead of opaque '_kind_N' indices. This ensures
no tree-sitter internal names appear in output.
Package clauses now extract the package name from the package_identifier
child node, showing 'package handler' instead of '_package_clause_0'.
New and deleted code files now show a declaration summary listing all
top-level symbols with their signatures, rather than just 'file added'
or 'file deleted'. This gives the model a table-of-contents view of
what was added/removed.
Import declarations now show package names instead of opaque
_import_declaration_N identifiers. Go imports extract short package
names (e.g., 'fmt, http, context'). For large import blocks, shows
first two and count (e.g., 'fmt, http, ... (5 packages)').
Import blocks are keyed by position rather than name, so changing the
imported packages shows as 'modified' with inline diff instead of
separate remove+add entries.
Added declarations now show their signature (first line) to give
context about what was added, rather than just the word 'added'.
Integrates the semantic diff engine into existing tools that return
file patches:
- get_commit: Adds Patch field to MinimalCommitFile and applies
semantic diff for supported formats (JSON, YAML, CSV, TOML) and
structural diff for code files
- pull_request_read (get_diff): Splits multi-file raw diff by file
and applies semantic diff per-file where beneficial
- pull_request_read (get_files): Applies semantic diff to each
file's Patch field before returning
Unsupported file types keep their original unified diff patches
unchanged. Patches are reconstructed from hunks to feed the semantic
diff engine — this works well for structured data where the full
content is typically in the diff.
Adds InstructionsFunc to the repos toolset describing how to combine
compare_file_contents (structural diff) with get_file_contents symbol
extraction for efficient code review. Server instructions focus on
multi-tool flows only — single-tool features are already documented
in each tool's own description.
Adds an optional 'symbol' parameter to get_file_contents that uses
tree-sitter to extract a specific named symbol (function, class, type,
method, etc.) from a file. Instead of returning the entire file, only
the matching symbol's source code is returned.
Supports all languages from the structural diff engine: Go, Python,
JavaScript, TypeScript, Ruby, Rust, Java, C/C++. For unsupported
file types, returns an error suggesting the feature is not available.
If the symbol is not found, the error message includes a list of
available symbols in the file to help the model self-correct.
This pairs well with the structural diff tool — a model can see which
symbols changed via compare_file_contents, then fetch specific symbols
via get_file_contents to examine them in detail.
CodeQL / Analyze (actions) (push) Has been cancelled
Build and Test Go Project / build (macos-latest) (push) Has been cancelled
Build and Test Go Project / build (ubuntu-latest) (push) Has been cancelled
Build and Test Go Project / build (windows-latest) (push) Has been cancelled
var_declaration and const_declaration nodes contain spec children
(var_spec, const_spec) with name fields. The Go name extractor now
handles these the same way as type_declaration, so nested diffs show
'var_declaration storeLine' instead of '_var_declaration_25'.
Modified declarations now show what changed inside them:
- Inline line-level diffs using LCS for precise change detection
- Whitespace-normalized comparison for brace languages (Go, JS, etc.)
so indentation-only changes collapse to '(whitespace/formatting only)'
- Exact comparison for whitespace-significant languages (Python)
- Recursive nesting into classes/modules to pinpoint which method changed
e.g. 'class Dog: modified > method bark: modified > line change'
- Max depth of 5 prevents unbounded recursion
- Added method_definition to JS/TS/TSX declaration kinds for class methods
Extends the compare_file_contents tool with AST-based structural
diffing for code files using tree-sitter. Instead of line-based diffs,
this shows declaration-level changes (functions, classes, types) which
gives models more concise and semantically meaningful context.
Supported languages: Go, Python, JavaScript, TypeScript, Ruby, Rust,
Java, C/C++.
Requires CGO_ENABLED=1 for the tree-sitter C bindings. Windows builds
are removed from goreleaser as CGO cross-compilation is not supported
without additional toolchain setup.
For unsupported languages, falls back to unified line-based diff.
Add a new compare_file_contents MCP tool that compares two versions of a
file across refs (branches, tags, or SHAs). For structured data formats
(JSON, YAML, CSV, TOML), it produces semantic diffs that show only
meaningful changes, ignoring formatting differences. For unsupported
formats, it falls back to unified diff.
Key features:
- Semantic diffs for JSON, YAML, CSV, TOML files
- Unified diff fallback for code and other text files
- Handles new files (base not found) and deleted files (head not found)
- 1MB max file size to prevent excessive server-side processing
- Gated behind 'compare_file_contents' feature flag
This helps AI models by:
- Reducing token usage (formatting noise eliminated)
- Providing unambiguous before/after semantics
- Enabling self-verification of edits to config/data files
Refs: #1973
* Update snapshots
There was a change on `main` before I changed anything
* feat: add add_reply_to_pull_request_comment tool
Add a new tool that allows AI agents to reply to existing pull request comments. This tool uses GitHub's CreateCommentInReplyTo REST API to create threaded conversations on pull requests.
Features:
Reply to any existing PR comment using its ID
Proper error handling for missing parameters and API failures
Comprehensive test coverage (8 test cases)
Follows project patterns and conventions
Registered in pull_requests toolset as a write operation
Parameters:
owner: Repository owner (required)
repo: Repository name (required)
pullNumber: Pull request number (required)
commentId: ID of comment to reply to (required)
body: Reply text content (required)
This tool complements the existing add_comment_to_pending_review tool by enabling responses to already-posted comments, enhancing AI-powered code review workflows.
Closes: #635
* Update README
* fix types
---------
Co-authored-by: tommaso-moro <tommaso-moro@github.com>
Co-authored-by: Tommaso Moro <37270480+tommaso-moro@users.noreply.github.com>
Co-authored-by: plaskowski <1999603+plaskowski@users.noreply.github.com>
Co-authored-by: Rob Emanuele <2320142+lossyrob@users.noreply.github.com>
- Extract dual-fetch logic into listProjectsFromBothOwnerTypes helper
- Rename addProjectItemWithResolution to addProjectItem (old function removed)
- Add GraphQL test coverage for add_project_item using githubv4mock
- Tests cover both org/issue and user/pull_request success paths
Add MCP progress notifications during the PR polling loop to provide
real-time status updates while waiting for Copilot to create a PR.
Changes:
- Use the request parameter to access the ServerSession for notifications
- Send an initial progress notification when polling starts
- Send progress updates on each polling attempt with attempt count
- Only send notifications when progressToken is provided by the client
This aligns with the behavior in create_pull_request_with_copilot tool
and improves the user experience during the waiting period.
Replace inline GraphQL-Features header logic in bearerAuthTransport with
the exported GraphQLFeaturesTransport. This removes code duplication and
ensures the transport is actually used, not just exported.
- Document GraphQLFeaturesTransport is for library consumers
- Convert githubv4.Int/String to native Go types in result map
- Remove misleading log comment since tool handlers lack logger access
When polling for a linked PR after assigning Copilot to an issue,
we now capture the assignment time before the mutation and filter
to only return PRs created after that time. This prevents the tool
from incorrectly returning old PRs from previous Copilot assignments.
Enhances the assign_copilot_to_issue tool to automatically poll for
the PR created by the Copilot coding agent after assignment.
Changes:
- Add findLinkedCopilotPR() to query issue timeline for CrossReferencedEvent
items from PRs authored by copilot-swe-agent
- Add polling loop (9 attempts, 1s delay) matching remote server latency
- Return structured JSON with PR details when found, or helpful note otherwise
- Add PollConfig for configurable polling (used in tests to disable)
- Add GraphQLFeaturesTransport for feature flag header support
The returned response now includes:
- issue_number, issue_url, owner, repo
- pull_request object (if found during polling)
- Note with instructions to use get_copilot_job_status if PR not yet created
* wip injecting ff function into tool as dep
* remove debug
* fix linter
* add better test
* adding compile time check
* move experimental to seperate config/ff value
* adding test var
* fixing test
* adding flag and possibility to call feature checker
* fixing name
- Add http.StatusNoContent (204) to the list of accepted success status codes
- Add test case for 204 response when marking notification as done
- Retain existing test for 200 response for backwards compatibility
Co-authored-by: SamMorrowDrums <4811358+SamMorrowDrums@users.noreply.github.com>
- Added optional custom_instructions parameter to tool schema
- Updated implementation to pass custom instructions to agent assignment
- Added test case to verify custom_instructions works correctly
- Updated toolsnaps and documentation
The custom_instructions parameter allows users to provide additional
context, constraints, or guidance to the Copilot agent beyond what's
in the issue body, addressing the issue where additional context
would otherwise be lost.
Co-authored-by: SamMorrowDrums <4811358+SamMorrowDrums@users.noreply.github.com>
* get it working
* clean up approach by moving cleantools inside builder, this simplifies remote server too
* add tests for trimming and deduplication
* error out in the builder if there are unrecognized tools
---------
Co-authored-by: Sam Morrow <info@sam-morrow.com>
Sort all JSON object keys alphabetically at every level in toolsnaps by
unmarshaling and remarshaling. This leverages Go's built-in behavior where
json.Marshal automatically sorts map keys alphabetically, ensuring
consistent field ordering and eliminating noop churn in diffs.
Co-authored-by: SamMorrowDrums <4811358+SamMorrowDrums@users.noreply.github.com>
- Add context-based GraphQL feature flag support
- Modify bearerAuthTransport to read features from context and add GraphQL-Features header
- Use issues_copilot_assignment_api_support feature flag for updateIssue mutation
- Export GetGraphQLFeatures function for use in HTTP transport layer
This allows the assign_copilot_to_issue tool to work with the non-GA agent assignment API
by sending the required GraphQL-Features header.
Co-authored-by: SamMorrowDrums <4811358+SamMorrowDrums@users.noreply.github.com>
- Add optional base_ref parameter to tool schema
- Change from replaceActorsForAssignable to updateIssue mutation with agentAssignment
- Add AgentAssignmentInput and UpdateIssueInput structs for new GraphQL mutation
- Update all tests to use new mutation structure
- Add test case for base_ref functionality
- Update toolsnaps and documentation
Co-authored-by: SamMorrowDrums <4811358+SamMorrowDrums@users.noreply.github.com>
The RepositoryResourceContentsHandler was using closure-captured deps
instead of retrieving them from context at call time. This causes issues
on the remote server which injects per-request deps via context.
Changed to use MustDepsFromContext(ctx) pattern consistent with tool
handlers in NewTool and NewToolFromHandler.
The CompleteParams.Context field is optional (marked omitempty) and can be
nil when clients don't send it. The code was accessing Context.Arguments
directly without checking if Context was nil first, causing a panic.
This fix adds a nil check for Context before accessing Arguments.
Add the ability to filter tools based on token scopes for PAT users.
This uses an HTTP HEAD request to GitHub's API to discover token scopes.
New components:
- pkg/scopes/filter.go: HasRequiredScopes checks if scopes satisfy tool requirements
- pkg/scopes/fetcher.go: FetchTokenScopes gets scopes via HTTP HEAD to GitHub API
- pkg/github/scope_filter.go: CreateScopeFilter creates inventory.ToolFilter
Integration:
- Add --filter-by-scope flag to stdio command (disabled by default)
- When enabled, fetches token scopes on startup
- Tools requiring unavailable scopes are hidden from tool list
- Gracefully continues without filtering if scope fetch fails (logs warning)
This allows the OSS server to have similar scope-based tool visibility
as the remote server, and the filter logic can be reused by remote server.
public_repo is implicit - the GitHub API handles the distinction between
public and private repos. Using repo as the required scope is more
consistent with our enforcement model:
- PATs: tools visible if token has repo scope
- OAuth: scope challenge requests repo scope
Sam Morrow