cycles

Documentation

Index

• type CapacityRecommendation
  • func GenerateCapacityRecommendation(analysis *CycleAnalysis, isPerUser bool) *CapacityRecommendation
• type Client
  • func NewClient(base *core.BaseClient) *Client
  • func (cc *Client) ArchiveCycle(cycleID string) error
  • func (cc *Client) CreateCycle(input *core.CreateCycleInput) (*core.Cycle, error)
  • func (cc *Client) GetActiveCycle(teamID string) (*core.Cycle, error)
  • func (cc *Client) GetCycle(cycleID string) (*core.Cycle, error)
  • func (cc *Client) GetCycleIssues(cycleID string, limit int) ([]core.Issue, error)
  • func (cc *Client) ListCycles(filter *core.CycleFilter) (*core.CycleSearchResult, error)
  • func (cc *Client) UpdateCycle(cycleID string, input *core.UpdateCycleInput) (*core.Cycle, error)
• type CycleAnalysis
  • func AnalyzeMultipleCycles(cycles []*core.Cycle, userIssues map[string][]core.Issue) *CycleAnalysis
• type CycleMetrics
  • func CalculateCycleMetrics(cycle *core.Cycle, userIssues []core.Issue) *CycleMetrics

Types

type CapacityRecommendation

type CapacityRecommendation struct {
	ConservativeScope  int // P80 velocity
	TargetScope        int // Median velocity
	OptimisticScope    int // P20 velocity
	ConservativeIssues int // Based on avg points/issue
	TargetIssues       int
	OptimisticIssues   int
	Rationale          string // Explanation of calculation
}

CapacityRecommendation represents suggested cycle scope based on historical data

func GenerateCapacityRecommendation

func GenerateCapacityRecommendation(analysis *CycleAnalysis, isPerUser bool) *CapacityRecommendation

GenerateCapacityRecommendation creates scope recommendations based on analysis

type Client

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

CycleClient handles all cycle-related operations for the Linear API. It uses the shared BaseClient for HTTP communication and focuses on cycle (sprint/iteration) management functionality.

func NewClient

func NewClient(base *core.BaseClient) *Client

NewCycleClient creates a new cycle client with the provided base client

func (*Client) ArchiveCycle

func (cc *Client) ArchiveCycle(cycleID string) error

ArchiveCycle archives a cycle Why: Completed or obsolete cycles should be archived to keep the workspace clean.

func (*Client) CreateCycle

func (cc *Client) CreateCycle(input *core.CreateCycleInput) (*core.Cycle, error)

CreateCycle creates a new cycle in Linear Why: Teams need to create new sprints/iterations for planning work.

func (*Client) GetActiveCycle

func (cc *Client) GetActiveCycle(teamID string) (*core.Cycle, error)

GetActiveCycle retrieves the current active cycle for a team Why: Most common use case is finding what cycle is currently active for sprint planning and issue assignment.

func (*Client) GetCycle

func (cc *Client) GetCycle(cycleID string) (*core.Cycle, error)

GetCycle retrieves a single cycle by ID Why: This is the primary method for fetching detailed cycle information including progress metrics and state indicators.

func (*Client) GetCycleIssues

func (cc *Client) GetCycleIssues(cycleID string, limit int) ([]core.Issue, error)

GetCycleIssues retrieves issues for a specific cycle Why: Users need to see all issues in a cycle for sprint planning, progress tracking, and workload analysis.

func (*Client) ListCycles

func (cc *Client) ListCycles(filter *core.CycleFilter) (*core.CycleSearchResult, error)

ListCycles retrieves cycles with optional filtering Why: Users need to discover and browse cycles by team, status (active/future/past), with pagination support for large cycle histories.

func (*Client) UpdateCycle

func (cc *Client) UpdateCycle(cycleID string, input *core.UpdateCycleInput) (*core.Cycle, error)

UpdateCycle updates an existing cycle Why: Teams need to modify cycle dates, names, or mark cycles as completed.

type CycleAnalysis

type CycleAnalysis struct {
	CycleCount int
	Metrics    []CycleMetrics

	// Summary statistics
	AvgVelocity          float64 // average completedScope
	AvgCompletionRate    float64
	AvgScopeCreep        float64
	AvgScopeCreepPercent float64
	AvgThroughput        float64

	// Statistical measures
	StdDevVelocity float64
	MedianVelocity float64
	P80Velocity    float64 // 80th percentile (conservative)
	P20Velocity    float64 // 20th percentile (optimistic)
}

CycleAnalysis represents aggregated metrics across multiple cycles

func AnalyzeMultipleCycles

func AnalyzeMultipleCycles(cycles []*core.Cycle, userIssues map[string][]core.Issue) *CycleAnalysis

AnalyzeMultipleCycles aggregates metrics across multiple cycles

type CycleMetrics

type CycleMetrics struct {
	CycleID     string
	CycleName   string
	StartDate   string
	EndDate     string
	CompletedAt *string

	// Scope metrics
	InitialScope      int     // scopeHistory[0] or sum of initial issue estimates
	FinalScope        int     // scopeHistory[last] or sum of final issue estimates
	CompletedScope    int     // completedScopeHistory[last] or sum of completed issue estimates
	ScopeCreep        int     // finalScope - initialScope
	ScopeCreepPercent float64 // (scopeCreep / initialScope) * 100

	// Completion metrics
	CompletionRate float64 // (completedScope / finalScope) * 100

	// Issue metrics
	InitialIssueCount int // issueCountHistory[0] or count of initial issues
	CompletedIssues   int // completedIssueCountHistory[last] or count of completed issues
	Throughput        int // completedIssues
}

CycleMetrics represents calculated metrics for a single cycle

func CalculateCycleMetrics

func CalculateCycleMetrics(cycle *core.Cycle, userIssues []core.Issue) *CycleMetrics

CalculateCycleMetrics calculates metrics for a single cycle If userIssues is nil/empty, uses cycle history arrays (team-wide analysis) If userIssues is provided, calculates from filtered issues (per-user analysis)