Add show_diff chat tool and diff card

The Pipelines MCP server gains show_diff: it runs Git in a repository
inside the operator's home (default: the chat's directory) and records
the per-file patches. Without base it shows uncommitted work against
HEAD; with base it shows everything since the merge base (a pull
request preview), optionally committed changes only. Bounded at 300
files, 256 KiB per patch and 1 MiB total, with partial diffs labelled;
diff bodies share the per-chat retention budget with HTML views.

The chat draws the item as a card listing each changed file with its
stat; a row opens the existing file diff viewer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-21 17:08:02 +00:00
parent 79e5183469
commit 059eb1bb0d
15 changed files with 1077 additions and 16 deletions
+236
View File
@@ -0,0 +1,236 @@
package server
import (
"bytes"
"context"
"errors"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"time"
"unicode"
"git.a-wan.net/alan/pipelines/internal/chattools"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/workenv"
)
// The show_diff bounds. A larger diff is shown partially, never cut silently:
// files past the count are omitted (and counted), and a patch over the per-file
// or total size keeps its entry with a no-patch reason.
const (
showDiffMaxFiles = 300
showDiffMaxFileBytes = 256 << 10
showDiffMaxBytes = 1 << 20
showDiffTimeout = 30 * time.Second
// The empty tree is the base of a repository without commits.
gitEmptyTree = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
)
type showDiffRequest struct {
Path string
Base string
CommittedOnly bool
Title string
}
// runShowDiff compares a repository inside the operator's home and records
// the per-file patches as one diff item.
func (s *chatToolService) runShowDiff(ctx context.Context, sessionID string, in showDiffRequest) (*protocol.ChatShownItem, chattools.Result) {
fail := func(err error) (*protocol.ChatShownItem, chattools.Result) {
return nil, chattools.Result{Text: "Nothing was shown: " + err.Error(), IsError: true}
}
base := strings.TrimSpace(in.Base)
if in.CommittedOnly && base == "" {
return fail(errors.New("committed_only needs a base to compare against"))
}
if base != "" && !validGitRevision(base) {
return fail(fmt.Errorf("base %q is not a branch, tag or commit name", base))
}
directory, err := s.resolveDiffDirectory(ctx, sessionID, in.Path)
if err != nil {
return fail(err)
}
ctx, cancel := context.WithTimeout(ctx, showDiffTimeout)
defer cancel()
git := gitRunner{ctx: ctx, directory: directory}
top, err := git.output("rev-parse", "--show-toplevel")
if err != nil {
return fail(fmt.Errorf("%s is not inside a Git repository", directory))
}
git.directory = strings.TrimSpace(top)
body := protocol.ChatShownDiffBody{Repo: git.directory, Base: base, CommittedOnly: in.CommittedOnly}
head, headErr := git.output("rev-parse", "--verify", "--quiet", "HEAD^{commit}")
head = strings.TrimSpace(head)
if branch, err := git.output("symbolic-ref", "--quiet", "--short", "HEAD"); err == nil {
body.Head = strings.TrimSpace(branch)
} else if head != "" {
body.Head = shortCommit(head)
}
var compare string
switch {
case base != "":
if headErr != nil || head == "" {
return fail(errors.New("this repository has no commits yet, so there is nothing to compare with " + base))
}
target, err := git.output("rev-parse", "--verify", "--quiet", "--end-of-options", base+"^{commit}")
if err != nil {
return fail(fmt.Errorf("base %q is not a commit in %s", base, git.directory))
}
mergeBase, err := git.output("merge-base", strings.TrimSpace(target), head)
if err != nil {
return fail(fmt.Errorf("%s and HEAD share no history", base))
}
compare = strings.TrimSpace(mergeBase)
case headErr == nil && head != "":
compare = head
default:
compare = gitEmptyTree
}
if compare != gitEmptyTree {
body.BaseCommit = shortCommit(compare)
}
revisions := []string{compare}
if in.CommittedOnly {
revisions = append(revisions, head)
}
changes, err := collectGitDiff(git, revisions, !in.CommittedOnly)
if err != nil {
return fail(err)
}
body.Changes = changes
diffBytes := 0
for _, file := range changes.Files {
added, removed := patchLineCounts(file.Patch)
body.Additions += added
body.Deletions += removed
diffBytes += len(file.Patch)
}
body.Files = len(changes.Files) + changes.Omitted
item := protocol.ChatShownItem{Kind: protocol.ChatShownDiff, Title: in.Title, Diff: &body, DiffBytes: diffBytes}
return &item, chattools.Result{Text: showDiffSummary(body)}
}
func showDiffSummary(body protocol.ChatShownDiffBody) string {
against := "HEAD"
switch {
case body.Base != "" && body.CommittedOnly:
against = fmt.Sprintf("%s (merge base %s), committed changes only", body.Base, body.BaseCommit)
case body.Base != "":
against = fmt.Sprintf("%s (merge base %s), including uncommitted work", body.Base, body.BaseCommit)
case body.BaseCommit == "":
against = "an empty repository"
}
if body.Files == 0 {
return fmt.Sprintf("Shown in the operator's Pipelines chat: no changes in %s against %s.", body.Repo, against)
}
text := fmt.Sprintf("Shown in the operator's Pipelines chat: %d changed %s (+%d -%d) in %s against %s.",
body.Files, plural(body.Files, "file", "files"), body.Additions, body.Deletions, body.Repo, against)
if body.Changes != nil && body.Changes.Status != "complete" {
text += " The diff is partial: " + body.Changes.Diagnostic
}
return text
}
func plural(n int, one, many string) string {
if n == 1 {
return one
}
return many
}
// resolveDiffDirectory applies the home containment of show_file to a
// directory, defaulting to the chat's working directory.
func (s *chatToolService) resolveDiffDirectory(ctx context.Context, sessionID, requested string) (string, error) {
requested = strings.TrimSpace(requested)
home, err := s.home()
if err != nil {
return "", err
}
realHome, err := filepath.EvalSymlinks(filepath.Clean(home))
if err != nil {
return "", errors.New("the operator's home directory is not available")
}
if requested == "" || (!filepath.IsAbs(requested) && !strings.HasPrefix(requested, "~")) {
directory := s.chatSessionDirectory(ctx, sessionID)
if directory == "" {
return "", errors.New("this chat has no recorded working directory; pass the repository's absolute path")
}
requested = filepath.Join(directory, requested)
}
target, err := expandHomePath(filepath.Clean(home), requested)
if err != nil {
return "", err
}
_, realTarget, err := resolveInsideHome(realHome, target)
if err != nil {
if strings.Contains(err.Error(), "outside the home directory") {
return "", errors.New(requested + " is outside the operator's home directory; only repositories inside home can be shown")
}
return "", err
}
info, err := os.Stat(realTarget)
if err != nil {
return "", describePathError(requested, err)
}
if !info.IsDir() {
return "", errors.New(requested + " is not a directory; pass the repository directory")
}
return realTarget, nil
}
// validGitRevision accepts a plain revision name: no option prefix, range,
// whitespace or control character, so it can only name one commit.
func validGitRevision(name string) bool {
if name == "" || len(name) > 200 || strings.HasPrefix(name, "-") || strings.Contains(name, "..") {
return false
}
for _, r := range name {
if unicode.IsSpace(r) || unicode.IsControl(r) {
return false
}
}
return true
}
// gitRunner runs git in one directory with the operator's environment and no
// pager, external diff, text conversion or path quoting.
type gitRunner struct {
ctx context.Context
directory string
}
func (g gitRunner) command(args ...string) *exec.Cmd {
full := append([]string{"-c", "core.quotepath=false", "-c", "core.fsmonitor=false", "-C", g.directory}, args...)
cmd := exec.CommandContext(g.ctx, "git", full...)
cmd.Env = append(workenv.CommandEnv(g.ctx, g.directory), "GIT_PAGER=cat", "GIT_OPTIONAL_LOCKS=0", "LC_ALL=C")
return cmd
}
func (g gitRunner) output(args ...string) (string, error) {
var stdout, stderr bytes.Buffer
cmd := g.command(args...)
cmd.Stdout, cmd.Stderr = &stdout, &stderr
if err := cmd.Run(); err != nil {
return "", fmt.Errorf("git %s: %v: %s", args[0], err, strings.TrimSpace(stderr.String()))
}
return stdout.String(), nil
}
// patch returns one file's patch. A `diff --no-index` exits 1 when the files
// differ, which is its success.
func (g gitRunner) patch(noIndex bool, args ...string) (string, error) {
var stdout, stderr bytes.Buffer
cmd := g.command(args...)
cmd.Stdout, cmd.Stderr = &stdout, &stderr
err := cmd.Run()
var exit *exec.ExitError
if err != nil && !(noIndex && errors.As(err, &exit) && exit.ExitCode() == 1) {
return "", fmt.Errorf("git diff: %v: %s", err, strings.TrimSpace(stderr.String()))
}
return stdout.String(), nil
}