gemfile

type AnalysisResult struct {
	// TotalGems is the total number of gems (first-level and transitive dependencies)
	TotalGems int
	// OutdatedGems is a list of gem names with available updates
	OutdatedGems []string
	// VulnerableGems is a list of gem names with known CVEs
	VulnerableGems []string
	// FirstLevelGems is a list of gem names directly required (in Gemfile/Gemfile.lock DEPENDENCIES)
	FirstLevelGems []string
	// AllGems is the complete list of parsed Gem objects
	AllGems []*Gem
	// GemStatuses is detailed status information for each gem (outdated, vulnerable, health, etc.)
	GemStatuses []*GemStatus
	// InsecureSourceGems is a list of gems sourced from insecure protocols (http://, git://)
	InsecureSourceGems []*Gem
	// Summary is a brief one-line summary of the analysis results
	Summary string
	// Details is a detailed report of all gems and their status
	Details string
}

type CVEComment struct {
	Decision   CVECommentDecision `json:"decision"`
	Comment    string             `json:"comment"`
	GemName    string             `json:"gem_name"`
	GemVersion string             `json:"gem_version"` // installed version at save time
	CreatedAt  time.Time          `json:"created_at"`
	UpdatedAt  time.Time          `json:"updated_at"`
}

type CVECommentDecision string

type CVEComments struct {
	Version int                    `json:"version"`
	Entries map[string]*CVEComment `json:"entries"` // key = CVE ID (vuln.CVE or vuln.OSVId)
}

type CacheEntry struct {
	GemsSignature   string          `json:"gems_signature"`
	CachedAt        time.Time       `json:"cached_at"`
	ScannedAt       time.Time       `json:"scanned_at"`
	TTLSeconds      int             `json:"ttl_seconds"`
	GemCount        int             `json:"gem_count"`
	ScanStatus      string          `json:"scan_status"` // "success" or "error"
	ErrorMessage    string          `json:"error_message,omitempty"`
	Vulnerabilities []Vulnerability `json:"vulnerabilities"`
}

type ConstraintResolver struct{}

type DependencyInfo struct {
	// GemName is the selected gem name
	GemName string
	// Version is the selected gem's version
	Version string
	// ForwardDeps lists the gems that this gem depends on (direct dependencies only)
	ForwardDeps []string
	// ReverseDeps lists the gems that depend on this gem (direct dependents only)
	ReverseDeps []string
	// ForwardDepsCount is the count of direct forward dependencies
	ForwardDepsCount int
	// ReverseDepsCount is the count of direct reverse dependencies
	ReverseDepsCount int
	// ForwardTree is a tree structure showing transitive dependencies of this gem
	ForwardTree *DependencyNode
	// ReverseTree is a tree structure showing what depends on this gem (up to 3 levels)
	ReverseTree *DependencyNode
}

type DependencyNode struct {
	// Name is the gem name
	Name string
	// Version is the gem version at this node
	Version string
	// Children are the direct dependencies (or dependents for reverse trees)
	Children []*DependencyNode
	// Depth is the nesting level in the tree (0 for root, increments for each level)
	Depth int
}

type DependencyResult struct {
	// SelectedGem is the name of the gem being analyzed
	SelectedGem string
	// DependencyInfo contains the dependency analysis for the selected gem
	DependencyInfo *DependencyInfo
	// AllGems is a reference to the full gem map for version lookups
	AllGems map[string]*Gem
}

type DependencyType int

type ErrCommandFailed struct {
	Binary string
	Cause  error
}

type ErrRubyNotFound struct {
	Binary string
}

type Gem struct {
	// Name is the lowercase gem name
	Name string
	// Version is the installed version string (may include platform suffixes like "x86_64-linux")
	Version string
	// Dependencies is a list of gem names that this gem depends on
	Dependencies []string
	// Groups lists the bundle groups this gem belongs to (e.g., "default", "development", "test", "production")
	Groups []string
	// IsFirstLevel is true if this gem is in the DEPENDENCIES section (directly required)
	IsFirstLevel bool
	// Source indicates where the gem is sourced from (e.g., "rubygems.org", a git URL)
	Source string
	// InsecureSource is true if the gem is sourced from an insecure protocol (http://, git://)
	InsecureSource bool
	// Constraint is the version constraint from Gemfile/gems.rb/gemspec (e.g., "~> 7.2", ">= 1.0")
	Constraint string
}

type GemHealth struct {
	// Score is the computed health tier (Healthy, Warning, Critical, Unknown)
	Score HealthScore `json:"score"`
	// LastRelease is the timestamp of the latest gem release from RubyGems
	LastRelease time.Time `json:"last_release"`
	// GitHubPushedAt is the timestamp of the last commit pushed to the repository
	GitHubPushedAt time.Time `json:"github_pushed_at"`
	// Stars is the number of GitHub stars on the repository
	Stars int `json:"stars"`
	// OpenIssues is the number of open issues on the repository
	OpenIssues int `json:"open_issues"`
	// Archived indicates whether the GitHub repository is archived
	Archived bool `json:"archived"`
	// Disabled indicates whether the GitHub repository is disabled
	Disabled bool `json:"disabled"`
	// MaintainerCount is the number of maintainers listed on RubyGems
	MaintainerCount int `json:"maintainer_count"`
	// RateLimited indicates if GitHub API rate limit was exceeded (partial data)
	RateLimited bool `json:"rate_limited"`
	// FetchedAt is the timestamp when this health data was fetched
	FetchedAt time.Time `json:"fetched_at"`
}

type GemStatus struct {
	// Name is the lowercase gem name
	Name string
	// Version is the currently installed version
	Version string
	// Groups lists the bundle groups this gem belongs to (e.g., "default", "development", "test")
	Groups []string
	// IsOutdated indicates whether a newer version is available
	IsOutdated bool
	// LatestVersion is the latest available version (only set if IsOutdated is true)
	LatestVersion string
	// IsVulnerable indicates whether known CVEs affect this gem version
	IsVulnerable bool
	// VulnerabilityInfo contains CVE ID and description (only set if IsVulnerable is true)
	VulnerabilityInfo string
	// VulnerabilityURL is the canonical OSV advisory URL (only set if IsVulnerable is true)
	VulnerabilityURL string
	// HomepageURL is the gem's homepage or source code repository URL
	HomepageURL string
	// Description is the gem description from rubygems.org
	Description string
	// Health contains gem maintenance status data (nil until fetched asynchronously)
	Health *GemHealth
	// OutdatedFailed is true if the outdated version check failed with an error
	OutdatedFailed bool
	// Constraint is the version constraint from Gemfile/gems.rb (e.g., "~> 7.2", ">= 1.0")
	Constraint string
	// UpdateableVersion is the highest version matching the constraint
	UpdateableVersion string
}

type Gemfile struct {
	// Path is the absolute path to the Gemfile.lock file
	Path string
	// Gems is a map of all gems (by lowercase name) found in the lock file
	Gems map[string]*Gem
	// FirstLevelGems is a list of gem names that are directly required (in DEPENDENCIES section)
	FirstLevelGems []string
}

type HealthChecker struct {
	// contains filtered or unexported fields
}

type HealthScore int

type InstalledVersion struct {
	Version string
	Path    string
}

type OSVBatchRequest struct {
	Queries []OSVQueryRequest `json:"queries"`
}

type OSVBatchResponse struct {
	Results []OSVResult `json:"results"`
}

type OSVClient struct {
	// contains filtered or unexported fields
}

type OSVPackage struct {
	Name      string `json:"name"`
	Ecosystem string `json:"ecosystem"`
}

type OSVQueryRequest struct {
	Package OSVPackage `json:"package"`
	Version string     `json:"version"`
}

type OSVResult struct {
	Vulns []OSVVulnerability `json:"vulns"`
}

type OSVVulnerability struct {
	ID               string                   `json:"id"`
	Summary          string                   `json:"summary"`
	Details          string                   `json:"details"`
	Published        string                   `json:"published"`
	Modified         string                   `json:"modified"`
	Severity         []map[string]interface{} `json:"severity"`          // Array of severity objects with type and score (CVSS string)
	DatabaseSpecific map[string]interface{}   `json:"database_specific"` // Contains severity for GitHub reviewed vulns
	References       []struct {
		Type string `json:"type"`
		URL  string `json:"url"`
	} `json:"references"`
	Affected []struct {
		Package struct {
			Name      string `json:"name"`
			Ecosystem string `json:"ecosystem"`
		} `json:"package"`
		Ranges []struct {
			Type   string `json:"type"`
			Events []struct {
				Introduced string `json:"introduced"`
				Fixed      string `json:"fixed"`
			} `json:"events"`
		} `json:"ranges"`
		EcosystemSpecific map[string]interface{} `json:"ecosystem_specific"` // Contains severity for some ecosystems
	} `json:"affected"`
}

type OutdatedChecker struct {
	// contains filtered or unexported fields
}

type ParsedGemInfo struct {
	Versions []InstalledVersion // Ordered list: newest first
}

type RepoOwnerPair struct {
	// GemName is the gem name
	GemName string
	// Owner is the GitHub repository owner
	Owner string
	// Repo is the GitHub repository name
	Repo string
}

type RubygemeInfo struct {
	// Version is the latest available version of the gem
	Version string `json:"version"`
	// VersionCreatedAt is the timestamp when the latest version was released
	VersionCreatedAt string `json:"version_created_at"`
	// HomepageURI is the gem's official homepage URL
	HomepageURI string `json:"homepage_uri"`
	// SourceCodeURI is the source code repository URL
	SourceCodeURI string `json:"source_code_uri"`
	// Info is the gem's description
	Info string `json:"info"`
}

type RubygemesDependency struct {
	// Name is the name of the dependency gem
	Name string `json:"name"`
	// Requirements describes the version constraint(s) for this dependency
	Requirements interface{} `json:"requirements"`
}

type RubygemsDependencies struct {
	// Runtime dependencies (production gems required for the app to run)
	Runtime []RubygemesDependency `json:"runtime"`
	// Development dependencies (development and test gems)
	Development []RubygemesDependency `json:"development"`
}

type UpgradeResult struct {
	GemName string
	Success bool
	Error   string
}

type Vulnerability struct {
	// GemName is the affected gem (lowercase)
	GemName string
	// AffectedVersions is a list of version specs that are vulnerable (e.g., "< 6.1.4", ">= 6.0.0, < 6.0.5")
	AffectedVersions []string
	// Description is a brief summary of the vulnerability
	Description string
	// CVE is the CVE identifier (e.g., "CVE-2021-22942")
	CVE string
	// Severity is the vulnerability severity level (CRITICAL, HIGH, MODERATE, LOW)
	Severity string
	// CVSS is the CVSS score (0-10)
	CVSS float64
	// FixedVersion is the first version that fixes the vulnerability
	FixedVersion string
	// PublishedDate is when the vulnerability was published
	PublishedDate time.Time
	// References are links to additional information about the vulnerability
	References []string
	// OSVId is the OSV identifier (e.g., GHSA-xxxx or CVE-2021-xxxx)
	OSVId string
	// Source indicates where the vulnerability data came from (e.g., "osv.dev", "static")
	Source string
	// Workarounds are temporary mitigations if no upgrade is immediately available
	Workarounds string
}