GitManager/internal/service/service.go

// Package service is the ONE capability layer behind both the HTTP API and the
// MCP server (AGENT.md §1.7). HTTP handlers and MCP tool handlers are thin
// adapters that call these methods; Git/forge logic never lives in a handler.
// Everything here goes through the internal/git (and later internal/forge)
// boundaries and obeys the safety rules (§1.4).
package service

import (
	"context"
	"fmt"
	"path/filepath"

	"gitmanager/internal/activity"
	"gitmanager/internal/forge"
	"gitmanager/internal/git"
	"gitmanager/internal/repos"
)

// Service holds the shared dependencies the capabilities need.
type Service struct {
	git   *git.CLI
	index *repos.Index
	feed  *activity.Feed
	forge *forge.Gitea // nil when no forge is configured
}

// New builds a Service over the git boundary, the scanner's repo index, the
// activity feed, and (optionally) a forge provider.
func New(g *git.CLI, index *repos.Index, feed *activity.Feed, fg *forge.Gitea) *Service {
	return &Service{git: g, index: index, feed: feed, forge: fg}
}

// ListRepos returns a snapshot of every discovered repository.
func (s *Service) ListRepos() []repos.State {
	return s.index.List()
}

// GetRepo returns the cached state for one repo, or false if it is not indexed.
// The path is cleaned so separator style does not defeat the exact-match lookup.
func (s *Service) GetRepo(path string) (repos.State, bool) {
	return s.index.Get(filepath.Clean(path))
}

// RepoDetail returns the enriched detail (branches, commits, remotes) for one
// repo. The second return is false when the path is not an indexed repository —
// we never run git against an arbitrary caller-supplied path (§1.3).
func (s *Service) RepoDetail(ctx context.Context, path string) (repos.Detail, bool) {
	base, ok := s.index.Get(filepath.Clean(path))
	if !ok {
		return repos.Detail{}, false
	}
	return repos.BuildDetail(ctx, s.git, base), true
}

// --- Activity & active project (§8.2) --------------------------------------

// ActiveProject returns the current active project path ("" if none).
func (s *Service) ActiveProject() string {
	return s.feed.ActiveProject()
}

// SetActiveProject makes path the active project (or clears it when empty). It
// rejects a path that is not an indexed repository — the active project must be
// a real repo (§1.3). Returns the recorded event and whether it changed.
func (s *Service) SetActiveProject(actor activity.Actor, path string) (activity.Event, bool, error) {
	if path != "" {
		path = filepath.Clean(path)
		if _, ok := s.index.Get(path); !ok {
			return activity.Event{}, false, fmt.Errorf("unknown repository %q", path)
		}
	}
	ev, changed := s.feed.SetActiveProject(actor, path)
	return ev, changed, nil
}

// RecordActivity appends an arbitrary event to the feed.
func (s *Service) RecordActivity(actor activity.Actor, kind, repo, detail string) activity.Event {
	return s.feed.Record(actor, kind, repo, detail)
}

// Activity returns up to limit recent events, oldest first.
func (s *Service) Activity(limit int) []activity.Event {
	return s.feed.Events(limit)
}

// SubscribeActivity returns a channel of future events plus an unsubscribe func
// the caller must invoke when done.
func (s *Service) SubscribeActivity() (<-chan activity.Event, func()) {
	return s.feed.Subscribe()
}

// --- Graceful project handoff (§8.3) ---------------------------------------

// RequestSwitch records a user's request for Claude to switch to target. The
// target must be an indexed repository.
func (s *Service) RequestSwitch(actor activity.Actor, target, note string) (activity.PendingSwitch, error) {
	target = filepath.Clean(target)
	if _, ok := s.index.Get(target); !ok {
		return activity.PendingSwitch{}, fmt.Errorf("unknown repository %q", target)
	}
	return s.feed.RequestSwitch(actor, target, note), nil
}

// PendingSwitch returns the outstanding switch request, if any.
func (s *Service) PendingSwitch() (activity.PendingSwitch, bool) {
	return s.feed.PendingSwitch()
}

// AckSwitch completes the pending handoff on Claude's behalf: sets the active
// project to the requested target and records Claude's summary. Returns false if
// nothing was pending.
func (s *Service) AckSwitch(summary string) (activity.PendingSwitch, bool) {
	return s.feed.AckSwitch(activity.ActorClaude, summary)
}

// CancelSwitch clears a pending switch request.
func (s *Service) CancelSwitch(actor activity.Actor) (activity.PendingSwitch, bool) {
	return s.feed.CancelSwitch(actor)
}

// --- Forge (Gitea) — PRs and "Merge & clean up" (§8.4) ---------------------

// ForgeConfigured reports whether any forge provider is set up.
func (s *Service) ForgeConfigured() bool { return s.forge != nil }

// ForgePRs lists open pull requests for a repo. Returns forge.ErrNotConfigured
// when no provider is set, or forge.ErrNotSupported when the repo's remote is not
// on the configured host.
func (s *Service) ForgePRs(ctx context.Context, repoPath string) ([]forge.PullRequest, error) {
	owner, repo, err := s.resolveForge(ctx, repoPath)
	if err != nil {
		return nil, err
	}
	return s.forge.ListPullRequests(ctx, owner, repo)
}

// MergeAndCleanup merges a PR and deletes its branch, then records the action.
// The caller is responsible for confirming with the user first (§1.4); actor
// distinguishes a UI action (user) from an MCP one (claude).
func (s *Service) MergeAndCleanup(ctx context.Context, actor activity.Actor, repoPath string, number int64) (forge.MergeResult, error) {
	owner, repo, err := s.resolveForge(ctx, repoPath)
	if err != nil {
		return forge.MergeResult{}, err
	}
	res, err := s.forge.MergeAndCleanup(ctx, owner, repo, number, forge.MergeSquash)
	if err != nil {
		return forge.MergeResult{}, err
	}
	detail := fmt.Sprintf("merged PR #%d", res.Number)
	if res.BranchDeleted && res.Branch != "" {
		detail += fmt.Sprintf(", deleted branch %s", res.Branch)
	}
	s.feed.Record(actor, "pr-merged", filepath.Clean(repoPath), detail)
	return res, nil
}

// resolveForge maps a repo path to (owner, repo) on the configured forge host via
// its git remotes, preferring "origin".
func (s *Service) resolveForge(ctx context.Context, repoPath string) (owner, repo string, err error) {
	if s.forge == nil {
		return "", "", forge.ErrNotConfigured
	}
	base, ok := s.index.Get(filepath.Clean(repoPath))
	if !ok {
		return "", "", fmt.Errorf("unknown repository %q", repoPath)
	}
	remotes, err := s.git.RemoteDetails(ctx, base.Path)
	if err != nil {
		return "", "", err
	}
	// Prefer origin, then any matching remote.
	var fallback [2]string
	haveFallback := false
	for _, rm := range remotes {
		host, o, r, ok := forge.ParseRemote(rm.URL)
		if !ok || !s.forge.Handles(host) {
			continue
		}
		if rm.Name == "origin" {
			return o, r, nil
		}
		if !haveFallback {
			fallback = [2]string{o, r}
			haveFallback = true
		}
	}
	if haveFallback {
		return fallback[0], fallback[1], nil
	}
	return "", "", forge.ErrNotSupported
}