João Salavisa
b3aaa804f1
* fix: use dynamic merge-base for git commits to filter main branch commits When a feature branch is rebased on main, the stored base_commit_sha becomes outdated. Using git log base_commit..HEAD would include main branch commits that were merged after the stored base commit. This fix adds dynamic merge-base calculation using the session's base_branch (target branch like origin/main). When fetching commits: - The backend computes git merge-base HEAD target_branch - This returns only commits not yet merged into the target branch - Works correctly even after rebases Changes: - Extended SessionReader interface with GetSessionBaseBranch method - Added GetMergeBase to GitOperator for computing merge-base - Updated git log API to accept target_branch parameter - Modified wsGitCommits handler to pass target branch for filtering * fix: update executor_test mock to match new GetGitLog signature * fix: update remaining mocks to match new GetGitLog signature * fix: update integration test mock for GetGitLog signature * fix: address code review feedback - Use GetOrEnsureExecution in wsGitCommits to recover workspaces after backend restarts - Fix archive snapshot to use baseBranch for merge-base when baseCommit is empty - Extended ExecutionLookup interface with GetOrEnsureExecution method * fix: distinguish not-ready errors from unexpected errors in wsGitCommits Address CodeRabbit review feedback: - Use errors.Is() to detect ErrSessionWorkspaceNotReady sentinel error - Return ready:false gracefully for workspace-not-ready and session-not-ready errors - Return actual errors for unexpected failures (database errors, etc.) - Add comprehensive tests for error handling paths
460 lines
16 KiB
Go
460 lines
16 KiB
Go
package client
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
)
|
|
|
|
// GitOperationResult represents the result of a git operation.
|
|
// This matches the server-side process.GitOperationResult.
|
|
type GitOperationResult struct {
|
|
Success bool `json:"success"`
|
|
Operation string `json:"operation"`
|
|
Output string `json:"output"`
|
|
Error string `json:"error,omitempty"`
|
|
ConflictFiles []string `json:"conflict_files,omitempty"`
|
|
}
|
|
|
|
// PRCreateResult represents the result of a PR creation operation.
|
|
// This matches the server-side process.PRCreateResult.
|
|
type PRCreateResult struct {
|
|
Success bool `json:"success"`
|
|
PRURL string `json:"pr_url,omitempty"`
|
|
Output string `json:"output,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// GitPull performs a git pull operation on the worktree.
|
|
// If rebase is true, uses git pull --rebase.
|
|
func (c *Client) GitPull(ctx context.Context, rebase bool) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Rebase bool `json:"rebase"`
|
|
}{
|
|
Rebase: rebase,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/pull", payload)
|
|
}
|
|
|
|
// GitPush performs a git push operation on the worktree.
|
|
// If force is true, uses --force-with-lease.
|
|
// If setUpstream is true, uses --set-upstream.
|
|
func (c *Client) GitPush(ctx context.Context, force, setUpstream bool) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Force bool `json:"force"`
|
|
SetUpstream bool `json:"set_upstream"`
|
|
}{
|
|
Force: force,
|
|
SetUpstream: setUpstream,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/push", payload)
|
|
}
|
|
|
|
// GitRebase rebases the worktree branch onto the specified base branch.
|
|
// It first fetches origin/<baseBranch>, then rebases onto it.
|
|
func (c *Client) GitRebase(ctx context.Context, baseBranch string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
BaseBranch string `json:"base_branch"`
|
|
}{
|
|
BaseBranch: baseBranch,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/rebase", payload)
|
|
}
|
|
|
|
// GitMerge merges the specified base branch into the worktree branch.
|
|
// It first fetches origin/<baseBranch>, then merges it.
|
|
func (c *Client) GitMerge(ctx context.Context, baseBranch string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
BaseBranch string `json:"base_branch"`
|
|
}{
|
|
BaseBranch: baseBranch,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/merge", payload)
|
|
}
|
|
|
|
// GitAbort aborts an in-progress merge or rebase operation.
|
|
// The operation parameter must be "merge" or "rebase".
|
|
func (c *Client) GitAbort(ctx context.Context, operation string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Operation string `json:"operation"`
|
|
}{
|
|
Operation: operation,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/abort", payload)
|
|
}
|
|
|
|
// GitCommit creates a commit with the specified message.
|
|
// If stageAll is true, all changes are staged before committing.
|
|
// If amend is true, it amends the previous commit instead of creating a new one.
|
|
func (c *Client) GitCommit(ctx context.Context, message string, stageAll bool, amend bool) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Message string `json:"message"`
|
|
StageAll bool `json:"stage_all"`
|
|
Amend bool `json:"amend"`
|
|
}{
|
|
Message: message,
|
|
StageAll: stageAll,
|
|
Amend: amend,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/commit", payload)
|
|
}
|
|
|
|
// GitRenameBranch renames the current branch to a new name.
|
|
func (c *Client) GitRenameBranch(ctx context.Context, newName string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
NewName string `json:"new_name"`
|
|
}{
|
|
NewName: newName,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/rename-branch", payload)
|
|
}
|
|
|
|
// GitStage stages files for commit.
|
|
// If paths is empty, stages all changes (git add -A).
|
|
func (c *Client) GitStage(ctx context.Context, paths []string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Paths []string `json:"paths"`
|
|
}{
|
|
Paths: paths,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/stage", payload)
|
|
}
|
|
|
|
// GitUnstage unstages files from the index.
|
|
// If paths is empty, unstages all changes (git reset HEAD).
|
|
func (c *Client) GitUnstage(ctx context.Context, paths []string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Paths []string `json:"paths"`
|
|
}{
|
|
Paths: paths,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/unstage", payload)
|
|
}
|
|
|
|
// GitDiscard discards changes to files, reverting them to HEAD.
|
|
// Paths must not be empty - at least one file must be specified.
|
|
func (c *Client) GitDiscard(ctx context.Context, paths []string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
Paths []string `json:"paths"`
|
|
}{
|
|
Paths: paths,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/discard", payload)
|
|
}
|
|
|
|
// GitRevertCommit undoes the latest commit using git reset --soft, keeping changes staged.
|
|
func (c *Client) GitRevertCommit(ctx context.Context, commitSHA string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
CommitSHA string `json:"commit_sha"`
|
|
}{
|
|
CommitSHA: commitSHA,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/revert-commit", payload)
|
|
}
|
|
|
|
// GitReset resets HEAD to the specified commit.
|
|
// Mode can be "soft" (keep changes staged), "mixed" (keep changes unstaged), or "hard" (discard all changes).
|
|
func (c *Client) GitReset(ctx context.Context, commitSHA, mode string) (*GitOperationResult, error) {
|
|
payload := struct {
|
|
CommitSHA string `json:"commit_sha"`
|
|
Mode string `json:"mode"`
|
|
}{
|
|
CommitSHA: commitSHA,
|
|
Mode: mode,
|
|
}
|
|
return c.gitOperation(ctx, "/api/v1/git/reset", payload)
|
|
}
|
|
|
|
// GitCreatePR creates a pull request using the gh CLI.
|
|
func (c *Client) GitCreatePR(ctx context.Context, title, body, baseBranch string, draft bool) (*PRCreateResult, error) {
|
|
payload := struct {
|
|
Title string `json:"title"`
|
|
Body string `json:"body"`
|
|
BaseBranch string `json:"base_branch"`
|
|
Draft bool `json:"draft"`
|
|
}{
|
|
Title: title,
|
|
Body: body,
|
|
BaseBranch: baseBranch,
|
|
Draft: draft,
|
|
}
|
|
|
|
reqBody, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to marshal request: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v1/git/create-pr", bytes.NewReader(reqBody))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to execute request: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
respBody, err := readResponseBody(resp)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
|
|
var result PRCreateResult
|
|
if err := json.Unmarshal(respBody, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response (status %d, body: %s): %w",
|
|
resp.StatusCode, truncateBody(respBody), err)
|
|
}
|
|
|
|
// For 409 Conflict (operation in progress), return the result with error set
|
|
// For other HTTP errors, return as error
|
|
if resp.StatusCode >= 400 && resp.StatusCode != http.StatusConflict {
|
|
return &result, fmt.Errorf("create PR failed with status %d: %s", resp.StatusCode, result.Error)
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
// gitOperation is a helper that performs a git operation via HTTP POST.
|
|
func (c *Client) gitOperation(ctx context.Context, path string, payload interface{}) (*GitOperationResult, error) {
|
|
body, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to marshal request: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+path, bytes.NewReader(body))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to execute request: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
respBody, err := readResponseBody(resp)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
|
|
var result GitOperationResult
|
|
if err := json.Unmarshal(respBody, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response (status %d, body: %s): %w",
|
|
resp.StatusCode, truncateBody(respBody), err)
|
|
}
|
|
|
|
// For 409 Conflict (operation in progress), return the result with error set
|
|
// For other HTTP errors, return as error
|
|
if resp.StatusCode >= 400 && resp.StatusCode != http.StatusConflict {
|
|
return &result, fmt.Errorf("git operation failed with status %d: %s", resp.StatusCode, result.Error)
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
// CommitDiffResult represents the result of getting a commit's diff.
|
|
type CommitDiffResult struct {
|
|
Success bool `json:"success"`
|
|
CommitSHA string `json:"commit_sha"`
|
|
Message string `json:"message"`
|
|
Author string `json:"author"`
|
|
Date string `json:"date"`
|
|
Files map[string]interface{} `json:"files"`
|
|
FilesChanged int `json:"files_changed"`
|
|
Insertions int `json:"insertions"`
|
|
Deletions int `json:"deletions"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// GitShowCommit gets the diff for a specific commit.
|
|
func (c *Client) GitShowCommit(ctx context.Context, commitSHA string) (*CommitDiffResult, error) {
|
|
req, err := http.NewRequestWithContext(ctx, "GET", c.baseURL+"/api/v1/git/commit/"+commitSHA, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to execute request: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
respBody, err := readResponseBody(resp)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
|
|
var result CommitDiffResult
|
|
if err := json.Unmarshal(respBody, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response (status %d, body: %s): %w",
|
|
resp.StatusCode, truncateBody(respBody), err)
|
|
}
|
|
|
|
if resp.StatusCode >= 400 {
|
|
return &result, fmt.Errorf("git show commit failed with status %d: %s", resp.StatusCode, result.Error)
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
// GitLogResult represents the result of a git log operation.
|
|
type GitLogResult struct {
|
|
Success bool `json:"success"`
|
|
Commits []*GitCommitInfo `json:"commits"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// GitCommitInfo represents a single commit in the log.
|
|
// Field names match GitCommitData and SessionCommit for frontend consistency.
|
|
type GitCommitInfo struct {
|
|
CommitSHA string `json:"commit_sha"`
|
|
ParentSHA string `json:"parent_sha"`
|
|
CommitMessage string `json:"commit_message"`
|
|
AuthorName string `json:"author_name"`
|
|
AuthorEmail string `json:"author_email"`
|
|
CommittedAt string `json:"committed_at"`
|
|
FilesChanged int `json:"files_changed"`
|
|
Insertions int `json:"insertions"`
|
|
Deletions int `json:"deletions"`
|
|
}
|
|
|
|
// GitLog gets the commit log from baseCommit to HEAD.
|
|
// If baseCommit is empty, returns recent commits (limited by limit).
|
|
// If targetBranch is provided, computes merge-base dynamically for accurate filtering.
|
|
func (c *Client) GitLog(ctx context.Context, baseCommit string, limit int, targetBranch string) (*GitLogResult, error) {
|
|
reqURL := fmt.Sprintf("%s/api/v1/git/log?since=%s&limit=%d",
|
|
c.baseURL, url.QueryEscape(baseCommit), limit)
|
|
if targetBranch != "" {
|
|
reqURL += "&target_branch=" + url.QueryEscape(targetBranch)
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to execute request: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
respBody, err := readResponseBody(resp)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
|
|
var result GitLogResult
|
|
if err := json.Unmarshal(respBody, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response (status %d, body: %s): %w",
|
|
resp.StatusCode, truncateBody(respBody), err)
|
|
}
|
|
|
|
if resp.StatusCode >= 400 {
|
|
return &result, fmt.Errorf("git log failed with status %d: %s", resp.StatusCode, result.Error)
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
// CumulativeDiffResult represents the cumulative diff from base commit to HEAD.
|
|
type CumulativeDiffResult struct {
|
|
Success bool `json:"success"`
|
|
BaseCommit string `json:"base_commit"`
|
|
HeadCommit string `json:"head_commit"`
|
|
TotalCommits int `json:"total_commits"`
|
|
Files map[string]interface{} `json:"files"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// GetCumulativeDiff gets the cumulative diff from baseCommit to HEAD.
|
|
func (c *Client) GetCumulativeDiff(ctx context.Context, baseCommit string) (*CumulativeDiffResult, error) {
|
|
reqURL := fmt.Sprintf("%s/api/v1/git/cumulative-diff?base=%s", c.baseURL, url.QueryEscape(baseCommit))
|
|
|
|
req, err := http.NewRequestWithContext(ctx, "GET", reqURL, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to execute request: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
respBody, err := readResponseBody(resp)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
|
|
var result CumulativeDiffResult
|
|
if err := json.Unmarshal(respBody, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response (status %d, body: %s): %w",
|
|
resp.StatusCode, truncateBody(respBody), err)
|
|
}
|
|
|
|
if resp.StatusCode >= 400 {
|
|
return &result, fmt.Errorf("cumulative diff failed with status %d: %s", resp.StatusCode, result.Error)
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
// GitStatusResult represents the result of a git status query.
|
|
type GitStatusResult struct {
|
|
Success bool `json:"success"`
|
|
Branch string `json:"branch"`
|
|
RemoteBranch string `json:"remote_branch"`
|
|
HeadCommit string `json:"head_commit"`
|
|
BaseCommit string `json:"base_commit"` // Merge-base with origin branch
|
|
Ahead int `json:"ahead"`
|
|
Behind int `json:"behind"`
|
|
Modified []string `json:"modified"`
|
|
Added []string `json:"added"`
|
|
Deleted []string `json:"deleted"`
|
|
Untracked []string `json:"untracked"`
|
|
Renamed []string `json:"renamed"`
|
|
Files map[string]interface{} `json:"files"`
|
|
Timestamp string `json:"timestamp"`
|
|
BranchAdditions int `json:"branch_additions,omitempty"`
|
|
BranchDeletions int `json:"branch_deletions,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
}
|
|
|
|
// GetGitStatus gets the current git status from the workspace.
|
|
func (c *Client) GetGitStatus(ctx context.Context) (*GitStatusResult, error) {
|
|
req, err := http.NewRequestWithContext(ctx, "GET", c.baseURL+"/api/v1/git/status", nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to create request: %w", err)
|
|
}
|
|
|
|
resp, err := c.httpClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to execute request: %w", err)
|
|
}
|
|
defer func() { _ = resp.Body.Close() }()
|
|
|
|
respBody, err := readResponseBody(resp)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to read response body: %w", err)
|
|
}
|
|
|
|
var result GitStatusResult
|
|
if err := json.Unmarshal(respBody, &result); err != nil {
|
|
return nil, fmt.Errorf("failed to parse response (status %d, body: %s): %w",
|
|
resp.StatusCode, truncateBody(respBody), err)
|
|
}
|
|
|
|
if resp.StatusCode >= 400 {
|
|
return &result, fmt.Errorf("git status failed with status %d: %s", resp.StatusCode, result.Error)
|
|
}
|
|
|
|
return &result, nil
|
|
}
|