gitea-mcp/operation/repo/slim.go

package repo

import (
	gitea_sdk "code.gitea.io/sdk/gitea"
)

func userLogin(u *gitea_sdk.User) string {
	if u == nil {
		return ""
	}
	return u.UserName
}

func slimRepo(r *gitea_sdk.Repository) map[string]any {
	if r == nil {
		return nil
	}
	m := map[string]any{
		"id":                r.ID,
		"full_name":         r.FullName,
		"description":       r.Description,
		"html_url":          r.HTMLURL,
		"clone_url":         r.CloneURL,
		"ssh_url":           r.SSHURL,
		"default_branch":    r.DefaultBranch,
		"private":           r.Private,
		"fork":              r.Fork,
		"archived":          r.Archived,
		"language":          r.Language,
		"stars_count":       r.Stars,
		"forks_count":       r.Forks,
		"open_issues_count": r.OpenIssues,
		"open_pr_counter":   r.OpenPulls,
		"created_at":        r.Created,
		"updated_at":        r.Updated,
	}
	if r.Owner != nil {
		m["owner"] = r.Owner.UserName
	}
	if len(r.Topics) > 0 {
		m["topics"] = r.Topics
	}
	return m
}

func slimRepos(repos []*gitea_sdk.Repository) []map[string]any {
	out := make([]map[string]any, 0, len(repos))
	for _, r := range repos {
		out = append(out, slimRepo(r))
	}
	return out
}

func slimBranch(b *gitea_sdk.Branch) map[string]any {
	if b == nil {
		return nil
	}
	m := map[string]any{
		"name":      b.Name,
		"protected": b.Protected,
	}
	if b.Commit != nil {
		m["commit_sha"] = b.Commit.ID
	}
	return m
}

func slimBranches(branches []*gitea_sdk.Branch) []map[string]any {
	out := make([]map[string]any, 0, len(branches))
	for _, b := range branches {
		out = append(out, slimBranch(b))
	}
	return out
}

func slimCommit(c *gitea_sdk.Commit) map[string]any {
	if c == nil {
		return nil
	}
	m := map[string]any{
		"sha":      c.SHA,
		"html_url": c.HTMLURL,
		"created":  c.Created,
	}
	if c.RepoCommit != nil {
		m["message"] = c.RepoCommit.Message
		if c.RepoCommit.Author != nil {
			m["author"] = map[string]any{
				"name":  c.RepoCommit.Author.Name,
				"email": c.RepoCommit.Author.Email,
				"date":  c.RepoCommit.Author.Date,
			}
		}
	}
	return m
}

func slimCommits(commits []*gitea_sdk.Commit) []map[string]any {
	out := make([]map[string]any, 0, len(commits))
	for _, c := range commits {
		out = append(out, slimCommit(c))
	}
	return out
}

func slimTag(t *gitea_sdk.Tag) map[string]any {
	if t == nil {
		return nil
	}
	m := map[string]any{
		"name":    t.Name,
		"message": t.Message,
	}
	if t.Commit != nil {
		m["commit_sha"] = t.Commit.SHA
	}
	return m
}

func slimTags(tags []*gitea_sdk.Tag) []map[string]any {
	out := make([]map[string]any, 0, len(tags))
	for _, t := range tags {
		m := map[string]any{
			"name": t.Name,
		}
		if t.Commit != nil {
			m["commit_sha"] = t.Commit.SHA
		}
		out = append(out, m)
	}
	return out
}

func slimRelease(r *gitea_sdk.Release) map[string]any {
	if r == nil {
		return nil
	}
	return map[string]any{
		"id":           r.ID,
		"tag_name":     r.TagName,
		"target":       r.Target,
		"title":        r.Title,
		"body":         r.Note,
		"draft":        r.IsDraft,
		"prerelease":   r.IsPrerelease,
		"html_url":     r.HTMLURL,
		"author":       userLogin(r.Publisher),
		"created_at":   r.CreatedAt,
		"published_at": r.PublishedAt,
	}
}

func slimReleases(releases []*gitea_sdk.Release) []map[string]any {
	out := make([]map[string]any, 0, len(releases))
	for _, r := range releases {
		out = append(out, slimRelease(r))
	}
	return out
}

func slimContents(c *gitea_sdk.ContentsResponse) map[string]any {
	if c == nil {
		return nil
	}
	m := map[string]any{
		"name": c.Name,
		"path": c.Path,
		"sha":  c.SHA,
		"type": c.Type,
		"size": c.Size,
	}
	if c.Content != nil {
		m["content"] = *c.Content
	}
	if c.Encoding != nil {
		m["encoding"] = *c.Encoding
	}
	if c.HTMLURL != nil {
		m["html_url"] = *c.HTMLURL
	}
	if c.DownloadURL != nil {
		m["download_url"] = *c.DownloadURL
	}
	return m
}

func slimTree(t *gitea_sdk.GitTreeResponse) map[string]any {
	if t == nil {
		return nil
	}
	entries := make([]map[string]any, 0, len(t.Entries))
	for _, e := range t.Entries {
		entries = append(entries, map[string]any{
			"path": e.Path,
			"mode": e.Mode,
			"type": e.Type,
			"size": e.Size,
			"sha":  e.SHA,
		})
	}
	return map[string]any{
		"sha":         t.SHA,
		"truncated":   t.Truncated,
		"total_count": t.TotalCount,
		"tree":        entries,
	}
}

func slimRepoDetail(r *gitea_sdk.Repository) map[string]any {
	if r == nil {
		return nil
	}
	m := slimRepo(r)
	m["website"] = r.Website
	m["has_issues"] = r.HasIssues
	m["has_wiki"] = r.HasWiki
	m["has_pull_requests"] = r.HasPullRequests
	m["has_projects"] = r.HasProjects
	m["mirror"] = r.Mirror
	m["internal"] = r.Internal
	m["empty"] = r.Empty
	m["size"] = r.Size
	if r.Permissions != nil {
		m["permissions"] = map[string]any{
			"admin": r.Permissions.Admin,
			"push":  r.Permissions.Push,
			"pull":  r.Permissions.Pull,
		}
	}
	if r.Parent != nil {
		m["parent"] = map[string]any{
			"full_name": r.Parent.FullName,
			"html_url":  r.Parent.HTMLURL,
		}
	}
	return m
}

func slimUser(u *gitea_sdk.User) map[string]any {
	if u == nil {
		return nil
	}
	return map[string]any{
		"id":         u.ID,
		"login":      u.UserName,
		"full_name":  u.FullName,
		"email":      u.Email,
		"avatar_url": u.AvatarURL,
		"is_admin":   u.IsAdmin,
	}
}

func slimUsers(users []*gitea_sdk.User) []map[string]any {
	out := make([]map[string]any, 0, len(users))
	for _, u := range users {
		out = append(out, slimUser(u))
	}
	return out
}

func slimDeployKey(k *gitea_sdk.DeployKey) map[string]any {
	if k == nil {
		return nil
	}
	return map[string]any{
		"id":          k.ID,
		"title":       k.Title,
		"fingerprint": k.Fingerprint,
		"key":         k.Key,
		"url":         k.URL,
		"read_only":   k.ReadOnly,
		"created_at":  k.Created,
	}
}

func slimDeployKeys(keys []*gitea_sdk.DeployKey) []map[string]any {
	out := make([]map[string]any, 0, len(keys))
	for _, k := range keys {
		out = append(out, slimDeployKey(k))
	}
	return out
}

func slimBranchProtection(bp *gitea_sdk.BranchProtection) map[string]any {
	if bp == nil {
		return nil
	}
	return map[string]any{
		"branch_name":                bp.BranchName,
		"rule_name":                  bp.RuleName,
		"enable_push":               bp.EnablePush,
		"push_whitelist_usernames":   bp.PushWhitelistUsernames,
		"push_whitelist_teams":       bp.PushWhitelistTeams,
		"enable_merge_whitelist":     bp.EnableMergeWhitelist,
		"merge_whitelist_usernames":  bp.MergeWhitelistUsernames,
		"merge_whitelist_teams":      bp.MergeWhitelistTeams,
		"required_approvals":         bp.RequiredApprovals,
		"enable_approvals_whitelist": bp.EnableApprovalsWhitelist,
		"block_on_rejected_reviews":  bp.BlockOnRejectedReviews,
		"block_on_outdated_branch":   bp.BlockOnOutdatedBranch,
		"dismiss_stale_approvals":    bp.DismissStaleApprovals,
		"require_signed_commits":     bp.RequireSignedCommits,
		"protected_file_patterns":    bp.ProtectedFilePatterns,
		"unprotected_file_patterns":  bp.UnprotectedFilePatterns,
		"created_at":                 bp.Created,
		"updated_at":                 bp.Updated,
	}
}

func slimBranchProtections(bps []*gitea_sdk.BranchProtection) []map[string]any {
	out := make([]map[string]any, 0, len(bps))
	for _, bp := range bps {
		out = append(out, slimBranchProtection(bp))
	}
	return out
}

func slimHook(h *gitea_sdk.Hook) map[string]any {
	if h == nil {
		return nil
	}
	m := map[string]any{
		"id":         h.ID,
		"type":       h.Type,
		"active":     h.Active,
		"events":     h.Events,
		"created_at": h.Created,
		"updated_at": h.Updated,
	}
	if h.Config != nil {
		if url, ok := h.Config["url"]; ok {
			m["url"] = url
		}
		if ct, ok := h.Config["content_type"]; ok {
			m["content_type"] = ct
		}
	}
	return m
}

func slimHooks(hooks []*gitea_sdk.Hook) []map[string]any {
	out := make([]map[string]any, 0, len(hooks))
	for _, h := range hooks {
		out = append(out, slimHook(h))
	}
	return out
}

func slimDirEntries(entries []*gitea_sdk.ContentsResponse) []map[string]any {
	out := make([]map[string]any, 0, len(entries))
	for _, c := range entries {
		if c == nil {
			continue
		}
		out = append(out, map[string]any{
			"name": c.Name,
			"path": c.Path,
			"type": c.Type,
			"size": c.Size,
		})
	}
	return out
}