tenets.core.momentum Package

Development momentum and velocity tracking package.

This package provides comprehensive velocity tracking and momentum analysis for software development teams. It analyzes git history to understand development patterns, team productivity, and project velocity trends.

The momentum tracker helps teams understand their development pace, identify bottlenecks, and make data-driven decisions about resource allocation and sprint planning.

Main components: - VelocityTracker: Main tracker for development velocity - MomentumMetrics: Metrics calculation for momentum - SprintAnalyzer: Sprint-based velocity analysis - TeamVelocity: Team-level velocity tracking - ProductivityAnalyzer: Individual and team productivity analysis

Example usage

from tenets.core.momentum import VelocityTracker from tenets.config import TenetsConfig

config = TenetsConfig() tracker = VelocityTracker(config)

Track momentum for the last month

report = tracker.track_momentum( ... repo_path=Path("."), ... period="last-month", ... team=True ... )

print(f"Team velocity: {report.team_velocity}") print(f"Sprint completion: {report.sprint_completion}%")

Classes

MomentumMetricsdataclass

Python

MomentumMetrics(momentum_score: float = 0.0, velocity_score: float = 0.0, quality_score: float = 0.0, collaboration_score: float = 0.0, productivity_score: float = 0.0, momentum_trend: str = 'stable', acceleration: float = 0.0, sustainability: float = 0.0, risk_factors: List[str] = list(), opportunities: List[str] = list(), health_indicators: Dict[str, bool] = dict())

Overall momentum metrics for development.

Aggregates various metrics to provide a comprehensive view of development momentum and project health.

ATTRIBUTE	DESCRIPTION
momentum_score	Overall momentum score (0-100) TYPE:float
velocity_score	Velocity component score TYPE:float
quality_score	Quality component score TYPE:float
collaboration_score	Collaboration component score TYPE:float
productivity_score	Productivity component score TYPE:float
momentum_trend	Momentum trend direction TYPE:str
acceleration	Rate of momentum change TYPE:float
sustainability	Momentum sustainability score TYPE:float
risk_factors	Identified risk factors TYPE:List[str]
opportunities	Identified opportunities TYPE:List[str]
health_indicators	Key health indicators TYPE:Dict[str, bool]

Attributes

momentum_scoreclass-attributeinstance-attribute

Python

momentum_score: float = 0.0

velocity_scoreclass-attributeinstance-attribute

Python

velocity_score: float = 0.0

quality_scoreclass-attributeinstance-attribute

Python

quality_score: float = 0.0

collaboration_scoreclass-attributeinstance-attribute

Python

collaboration_score: float = 0.0

productivity_scoreclass-attributeinstance-attribute

Python

productivity_score: float = 0.0

momentum_trendclass-attributeinstance-attribute

Python

momentum_trend: str = 'stable'

accelerationclass-attributeinstance-attribute

Python

acceleration: float = 0.0

sustainabilityclass-attributeinstance-attribute

Python

sustainability: float = 0.0

risk_factorsclass-attributeinstance-attribute

Python

risk_factors: List[str] = field(default_factory=list)

opportunitiesclass-attributeinstance-attribute

Python

opportunities: List[str] = field(default_factory=list)

health_indicatorsclass-attributeinstance-attribute

Python

health_indicators: Dict[str, bool] = field(default_factory=dict)

is_healthyproperty

Python

is_healthy: bool

Check if momentum is healthy.

RETURNS	DESCRIPTION
bool	True if momentum is healthy TYPE:bool

momentum_categoryproperty

Python

momentum_category: str

Categorize momentum level.

RETURNS	DESCRIPTION
str	Momentum category (excellent, good, fair, poor) TYPE:str

Functions

to_dict

Python

to_dict() -> Dict[str, Any]

Convert to dictionary representation.

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Dictionary representation

ProductivityMetricsdataclass

Python

ProductivityMetrics(overall_productivity: float = 0.0, avg_daily_commits: float = 0.0, avg_daily_lines: float = 0.0, code_churn: float = 0.0, rework_rate: float = 0.0, review_turnaround: float = 0.0, peak_productivity_date: Optional[datetime] = None, peak_productivity_score: float = 0.0, productivity_trend: str = 'stable', top_performers: List[Dict[str, Any]] = list(), bottlenecks: List[str] = list(), focus_areas: List[Tuple[str, int]] = list(), time_distribution: Dict[str, float] = dict())

Individual and team productivity measurements.

Tracks various productivity indicators to understand work efficiency, output quality, and areas for improvement.

ATTRIBUTE	DESCRIPTION
overall_productivity	Overall productivity score TYPE:float
avg_daily_commits	Average commits per day TYPE:float
avg_daily_lines	Average lines changed per day TYPE:float
code_churn	Code churn rate TYPE:float
rework_rate	Rate of rework/refactoring TYPE:float
review_turnaround	Average review turnaround time TYPE:float
peak_productivity_date	Date of peak productivity TYPE:Optional[datetime]
peak_productivity_score	Peak productivity score TYPE:float
productivity_trend	Productivity trend direction TYPE:str
top_performers	List of top performing contributors TYPE:List[Dict[str, Any]]
bottlenecks	Identified productivity bottlenecks TYPE:List[str]
focus_areas	Main areas of focus TYPE:List[Tuple[str, int]]
time_distribution	How time is distributed across activities TYPE:Dict[str, float]

Attributes

overall_productivityclass-attributeinstance-attribute

Python

overall_productivity: float = 0.0

avg_daily_commitsclass-attributeinstance-attribute

Python

avg_daily_commits: float = 0.0

avg_daily_linesclass-attributeinstance-attribute

Python

avg_daily_lines: float = 0.0

code_churnclass-attributeinstance-attribute

Python

code_churn: float = 0.0

rework_rateclass-attributeinstance-attribute

Python

rework_rate: float = 0.0

review_turnaroundclass-attributeinstance-attribute

Python

review_turnaround: float = 0.0

peak_productivity_dateclass-attributeinstance-attribute

Python

peak_productivity_date: Optional[datetime] = None

peak_productivity_scoreclass-attributeinstance-attribute

Python

peak_productivity_score: float = 0.0

productivity_trendclass-attributeinstance-attribute

Python

productivity_trend: str = 'stable'

top_performersclass-attributeinstance-attribute

Python

top_performers: List[Dict[str, Any]] = field(default_factory=list)

bottlenecksclass-attributeinstance-attribute

Python

bottlenecks: List[str] = field(default_factory=list)

focus_areasclass-attributeinstance-attribute

Python

focus_areas: List[Tuple[str, int]] = field(default_factory=list)

time_distributionclass-attributeinstance-attribute

Python

time_distribution: Dict[str, float] = field(default_factory=dict)

efficiency_ratingproperty

Python

efficiency_rating: str

Get efficiency rating based on productivity.

RETURNS	DESCRIPTION
str	Efficiency rating (excellent, good, fair, poor) TYPE:str

has_bottlenecksproperty

Python

has_bottlenecks: bool

Check if bottlenecks are identified.

RETURNS	DESCRIPTION
bool	True if bottlenecks exist TYPE:bool

Functions

to_dict

Python

to_dict() -> Dict[str, Any]

Convert to dictionary representation.

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Dictionary representation

SprintMetricsdataclass

Python

SprintMetrics(total_sprints: int = 0, avg_velocity: float = 0.0, max_velocity: float = 0.0, min_velocity: float = 0.0, velocity_trend: str = 'stable', sprint_data: List[Dict[str, Any]] = list(), completion_rate: float = 0.0, predictability: float = 0.0, burndown_efficiency: float = 0.0, scope_change_rate: float = 0.0, carry_over_rate: float = 0.0, sprint_health: str = 'unknown')

Sprint-based velocity and performance metrics.

Provides sprint-level analysis for teams using agile methodologies, tracking velocity, completion rates, and sprint health.

ATTRIBUTE	DESCRIPTION
total_sprints	Total number of sprints analyzed TYPE:int
avg_velocity	Average sprint velocity TYPE:float
max_velocity	Maximum sprint velocity TYPE:float
min_velocity	Minimum sprint velocity TYPE:float
velocity_trend	Trend in sprint velocity TYPE:str
sprint_data	Detailed data for each sprint TYPE:List[Dict[str, Any]]
completion_rate	Average sprint completion rate TYPE:float
predictability	Sprint predictability score TYPE:float
burndown_efficiency	Burndown chart efficiency TYPE:float
scope_change_rate	Rate of scope changes mid-sprint TYPE:float
carry_over_rate	Rate of work carried to next sprint TYPE:float
sprint_health	Overall sprint health assessment TYPE:str

Attributes

total_sprintsclass-attributeinstance-attribute

Python

total_sprints: int = 0

avg_velocityclass-attributeinstance-attribute

Python

avg_velocity: float = 0.0

max_velocityclass-attributeinstance-attribute

Python

max_velocity: float = 0.0

min_velocityclass-attributeinstance-attribute

Python

min_velocity: float = 0.0

velocity_trendclass-attributeinstance-attribute

Python

velocity_trend: str = 'stable'

sprint_dataclass-attributeinstance-attribute

Python

sprint_data: List[Dict[str, Any]] = field(default_factory=list)

completion_rateclass-attributeinstance-attribute

Python

completion_rate: float = 0.0

predictabilityclass-attributeinstance-attribute

Python

predictability: float = 0.0

burndown_efficiencyclass-attributeinstance-attribute

Python

burndown_efficiency: float = 0.0

scope_change_rateclass-attributeinstance-attribute

Python

scope_change_rate: float = 0.0

carry_over_rateclass-attributeinstance-attribute

Python

carry_over_rate: float = 0.0

sprint_healthclass-attributeinstance-attribute

Python

sprint_health: str = 'unknown'

velocity_consistencyproperty

Python

velocity_consistency: float

Calculate velocity consistency across sprints.

RETURNS	DESCRIPTION
float	Consistency score (0-100) TYPE:float

is_healthyproperty

Python

is_healthy: bool

Check if sprint metrics indicate healthy process.

RETURNS	DESCRIPTION
bool	True if sprints are healthy TYPE:bool

Functions

to_dict

Python

to_dict() -> Dict[str, Any]

Convert to dictionary representation.

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Dictionary representation

TeamMetricsdataclass

Python

TeamMetrics(total_members: int = 0, active_members: int = 0, team_velocity: float = 0.0, collaboration_score: float = 0.0, efficiency_score: float = 0.0, bus_factor: int = 0, skill_diversity: float = 0.0, communication_score: float = 0.0, team_health: str = 'unknown', teams: Dict[str, Dict[str, Any]] = dict(), knowledge_silos: List[str] = list(), collaboration_matrix: Dict[Tuple[str, str], int] = dict())

Team-level productivity and collaboration metrics.

Measures team dynamics, collaboration patterns, and overall team effectiveness in delivering value.

ATTRIBUTE	DESCRIPTION
total_members	Total team members TYPE:int
active_members	Currently active members TYPE:int
team_velocity	Overall team velocity TYPE:float
collaboration_score	Team collaboration score TYPE:float
efficiency_score	Team efficiency score TYPE:float
bus_factor	Team bus factor (knowledge distribution) TYPE:int
skill_diversity	Skill diversity index TYPE:float
communication_score	Team communication effectiveness TYPE:float
team_health	Overall team health assessment TYPE:str
teams	Sub-team metrics if applicable TYPE:Dict[str, Dict[str, Any]]
knowledge_silos	Identified knowledge silos TYPE:List[str]
collaboration_matrix	Who collaborates with whom TYPE:Dict[Tuple[str, str], int]

Attributes

total_membersclass-attributeinstance-attribute

Python

total_members: int = 0

active_membersclass-attributeinstance-attribute

Python

active_members: int = 0

team_velocityclass-attributeinstance-attribute

Python

team_velocity: float = 0.0

collaboration_scoreclass-attributeinstance-attribute

Python

collaboration_score: float = 0.0

efficiency_scoreclass-attributeinstance-attribute

Python

efficiency_score: float = 0.0

bus_factorclass-attributeinstance-attribute

Python

bus_factor: int = 0

skill_diversityclass-attributeinstance-attribute

Python

skill_diversity: float = 0.0

communication_scoreclass-attributeinstance-attribute

Python

communication_score: float = 0.0

team_healthclass-attributeinstance-attribute

Python

team_health: str = 'unknown'

teamsclass-attributeinstance-attribute

Python

teams: Dict[str, Dict[str, Any]] = field(default_factory=dict)

knowledge_silosclass-attributeinstance-attribute

Python

knowledge_silos: List[str] = field(default_factory=list)

collaboration_matrixclass-attributeinstance-attribute

Python

collaboration_matrix: Dict[Tuple[str, str], int] = field(default_factory=dict)

participation_rateproperty

Python

participation_rate: float

Calculate team participation rate.

RETURNS	DESCRIPTION
float	Participation rate (0-100) TYPE:float

velocity_per_memberproperty

Python

velocity_per_member: float

Calculate average velocity per team member.

RETURNS	DESCRIPTION
float	Velocity per member TYPE:float

needs_attentionproperty

Python

needs_attention: bool

Check if team metrics indicate issues.

RETURNS	DESCRIPTION
bool	True if team needs attention TYPE:bool

Functions

to_dict

Python

to_dict() -> Dict[str, Any]

Convert to dictionary representation.

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Dictionary representation

VelocityTrenddataclass

Python

VelocityTrend(trend_direction: str = 'stable', avg_velocity: float = 0.0, max_velocity: float = 0.0, min_velocity: float = 0.0, std_deviation: float = 0.0, stability_score: float = 0.0, acceleration: float = 0.0, data_points: List[Dict[str, Any]] = list(), forecast: Optional[float] = None, confidence_level: float = 0.0, seasonal_pattern: Optional[str] = None, anomalies: List[Dict[str, Any]] = list())

Velocity trend analysis over time.

Tracks how development velocity changes over time, identifying patterns, trends, and stability in the development process.

ATTRIBUTE	DESCRIPTION
trend_direction	Direction of trend (increasing, decreasing, stable) TYPE:str
avg_velocity	Average velocity over period TYPE:float
max_velocity	Maximum velocity observed TYPE:float
min_velocity	Minimum velocity observed TYPE:float
std_deviation	Standard deviation of velocity TYPE:float
stability_score	Stability score (0-100, higher is more stable) TYPE:float
acceleration	Rate of change in velocity TYPE:float
data_points	List of velocity data points for visualization TYPE:List[Dict[str, Any]]
forecast	Predicted future velocity TYPE:Optional[float]
confidence_level	Confidence in forecast (0-1) TYPE:float
seasonal_pattern	Detected seasonal patterns TYPE:Optional[str]
anomalies	Detected anomalies in velocity TYPE:List[Dict[str, Any]]

Attributes

trend_directionclass-attributeinstance-attribute

Python

trend_direction: str = 'stable'

avg_velocityclass-attributeinstance-attribute

Python

avg_velocity: float = 0.0

max_velocityclass-attributeinstance-attribute

Python

max_velocity: float = 0.0

min_velocityclass-attributeinstance-attribute

Python

min_velocity: float = 0.0

std_deviationclass-attributeinstance-attribute

Python

std_deviation: float = 0.0

stability_scoreclass-attributeinstance-attribute

Python

stability_score: float = 0.0

accelerationclass-attributeinstance-attribute

Python

acceleration: float = 0.0

data_pointsclass-attributeinstance-attribute

Python

data_points: List[Dict[str, Any]] = field(default_factory=list)

forecastclass-attributeinstance-attribute

Python

forecast: Optional[float] = None

confidence_levelclass-attributeinstance-attribute

Python

confidence_level: float = 0.0

seasonal_patternclass-attributeinstance-attribute

Python

seasonal_pattern: Optional[str] = None

anomaliesclass-attributeinstance-attribute

Python

anomalies: List[Dict[str, Any]] = field(default_factory=list)

is_stableproperty

Python

is_stable: bool

Check if velocity is stable.

RETURNS	DESCRIPTION
bool	True if velocity is stable TYPE:bool

is_improvingproperty

Python

is_improving: bool

Check if velocity is improving.

RETURNS	DESCRIPTION
bool	True if velocity is increasing TYPE:bool

volatilityproperty

Python

volatility: float

Calculate velocity volatility.

Coefficient of variation as a measure of volatility.

RETURNS	DESCRIPTION
float	Volatility score (0-1) TYPE:float

Functions

to_dict

Python

to_dict() -> Dict[str, Any]

Convert to dictionary representation.

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Dictionary representation

MomentumReportdataclass

Python

MomentumReport(period_start: datetime, period_end: datetime, total_commits: int = 0, total_contributors: int = 0, active_contributors: int = 0, momentum_metrics: Optional[MomentumMetrics] = None, velocity_trend: Optional[VelocityTrend] = None, sprint_metrics: Optional[SprintMetrics] = None, team_metrics: Optional[TeamMetrics] = None, individual_velocities: List[ContributorVelocity] = list(), daily_breakdown: List[DailyVelocity] = list(), weekly_breakdown: List[WeeklyVelocity] = list(), productivity_metrics: Optional[ProductivityMetrics] = None, recommendations: List[str] = list(), health_score: float = 0.0)

Comprehensive momentum and velocity analysis report.

Aggregates all velocity metrics and trends to provide a complete picture of development momentum and team productivity.

ATTRIBUTE	DESCRIPTION
period_start	Start date of analysis period TYPE:datetime
period_end	End date of analysis period TYPE:datetime
total_commits	Total commits in period TYPE:int
total_contributors	Total unique contributors TYPE:int
active_contributors	Currently active contributors TYPE:int
momentum_metrics	Overall momentum metrics TYPE:Optional[MomentumMetrics]
velocity_trend	Velocity trend analysis TYPE:Optional[VelocityTrend]
sprint_metrics	Sprint-based metrics TYPE:Optional[SprintMetrics]
team_metrics	Team-level metrics TYPE:Optional[TeamMetrics]
individual_velocities	Individual contributor velocities TYPE:List[ContributorVelocity]
daily_breakdown	Daily velocity breakdown TYPE:List[DailyVelocity]
weekly_breakdown	Weekly velocity breakdown TYPE:List[WeeklyVelocity]
productivity_metrics	Productivity analysis TYPE:Optional[ProductivityMetrics]
recommendations	Actionable recommendations TYPE:List[str]
health_score	Overall momentum health score TYPE:float

Attributes

period_startinstance-attribute

Python

period_start: datetime

period_endinstance-attribute

Python

period_end: datetime

total_commitsclass-attributeinstance-attribute

Python

total_commits: int = 0

total_contributorsclass-attributeinstance-attribute

Python

total_contributors: int = 0

active_contributorsclass-attributeinstance-attribute

Python

active_contributors: int = 0

momentum_metricsclass-attributeinstance-attribute

Python

momentum_metrics: Optional[MomentumMetrics] = None

velocity_trendclass-attributeinstance-attribute

Python

velocity_trend: Optional[VelocityTrend] = None

sprint_metricsclass-attributeinstance-attribute

Python

sprint_metrics: Optional[SprintMetrics] = None

team_metricsclass-attributeinstance-attribute

Python

team_metrics: Optional[TeamMetrics] = None

individual_velocitiesclass-attributeinstance-attribute

Python

individual_velocities: List[ContributorVelocity] = field(default_factory=list)

daily_breakdownclass-attributeinstance-attribute

Python

daily_breakdown: List[DailyVelocity] = field(default_factory=list)

weekly_breakdownclass-attributeinstance-attribute

Python

weekly_breakdown: List[WeeklyVelocity] = field(default_factory=list)

productivity_metricsclass-attributeinstance-attribute

Python

productivity_metrics: Optional[ProductivityMetrics] = None

recommendationsclass-attributeinstance-attribute

Python

recommendations: List[str] = field(default_factory=list)

health_scoreclass-attributeinstance-attribute

Python

health_score: float = 0.0

avg_daily_velocityproperty

Python

avg_daily_velocity: float

Calculate average daily velocity.

RETURNS	DESCRIPTION
float	Average velocity per day TYPE:float

velocity_stabilityproperty

Python

velocity_stability: float

Calculate velocity stability score.

Lower variance indicates more stable/predictable velocity.

RETURNS	DESCRIPTION
float	Stability score (0-100) TYPE:float

Functions

to_dict

Python

to_dict() -> Dict[str, Any]

Convert report to dictionary.

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Dictionary representation

VelocityTracker

Python

VelocityTracker(config: TenetsConfig)

Main tracker for development velocity and momentum.

Orchestrates the analysis of git history to track development velocity, team productivity, and momentum trends over time.

ATTRIBUTE	DESCRIPTION
config	Configuration object
logger	Logger instance
git_analyzer	Git analyzer instance TYPE:Optional[GitAnalyzer]

Initialize velocity tracker.

PARAMETER	DESCRIPTION
config	TenetsConfig instance TYPE:TenetsConfig

Attributes

configinstance-attribute

Python

config = config

loggerinstance-attribute

Python

logger = get_logger(__name__)

git_analyzerinstance-attribute

Python

git_analyzer: Optional[GitAnalyzer] = None

Functions

track_momentum

Python

track_momentum(repo_path: Path, period: str = 'last-month', team: bool = False, author: Optional[str] = None, team_mapping: Optional[Dict[str, List[str]]] = None, sprint_duration: int = 14, daily_breakdown: bool = False, interval: str = 'weekly', exclude_bots: bool = True, **kwargs) -> MomentumReport

Track development momentum for a repository.

Analyzes git history to calculate velocity metrics, identify trends, and provide insights into development momentum.

PARAMETER	DESCRIPTION
repo_path	Path to git repository TYPE:Path
period	Time period to analyze (e.g., "last-month", "30 days") TYPE:strDEFAULT:'last-month'
team	Whether to include team-wide metrics TYPE:boolDEFAULT:False
author	Specific author to analyze TYPE:Optional[str]DEFAULT:None
team_mapping	Optional mapping of team names to members TYPE:Optional[Dict[str, List[str]]]DEFAULT:None
sprint_duration	Sprint length in days for sprint metrics TYPE:intDEFAULT:14
daily_breakdown	Whether to include daily velocity data TYPE:boolDEFAULT:False
interval	Aggregation interval (daily, weekly, monthly) TYPE:strDEFAULT:'weekly'
exclude_bots	Whether to exclude bot commits from analysis TYPE:boolDEFAULT:True

RETURNS	DESCRIPTION
MomentumReport	Comprehensive momentum analysis TYPE:MomentumReport

Example

tracker = VelocityTracker(config) report = tracker.track_momentum( ... Path("."), ... period="last-quarter", ... team=True ... ) print(f"Team velocity: {report.avg_daily_velocity}")

MomentumTracker

Python

MomentumTracker(config: TenetsConfig)

Bases: VelocityTracker

Compatibility alias for VelocityTracker.

The CLI historically imported MomentumTracker; we now unify to VelocityTracker but keep this subclass alias to preserve API without duplicating logic.

Functions

calculate_momentum_metrics

Python

calculate_momentum_metrics(daily_velocities: List[Any], individual_velocities: List[Any]) -> MomentumMetrics

Calculate overall momentum metrics from velocity data.

Aggregates various velocity and productivity data to compute comprehensive momentum metrics.

PARAMETER	DESCRIPTION
daily_velocities	List of daily velocity data TYPE:List[Any]
individual_velocities	List of individual contributor velocities TYPE:List[Any]

RETURNS	DESCRIPTION
MomentumMetrics	Calculated momentum metrics TYPE:MomentumMetrics

Example

metrics = calculate_momentum_metrics( ... daily_data, ... contributor_data ... ) print(f"Momentum score: {metrics.momentum_score}")

track_individual_velocity

Python

track_individual_velocity(repo_path: Path, author: str, period: str = 'last-month', config: Optional[TenetsConfig] = None) -> Optional[ContributorVelocity]

Track individual contributor velocity.

PARAMETER	DESCRIPTION
repo_path	Path to repository TYPE:Path
author	Author name or email TYPE:str
period	Time period to analyze TYPE:strDEFAULT:'last-month'
config	Optional configuration TYPE:Optional[TenetsConfig]DEFAULT:None

RETURNS	DESCRIPTION
Optional[ContributorVelocity]	Optional[ContributorVelocity]: Individual velocity metrics

track_momentum

Python

track_momentum(repo_path: Path, period: str = 'last-month', config: Optional[TenetsConfig] = None, **kwargs) -> MomentumReport

Convenience function to track momentum.

PARAMETER	DESCRIPTION
repo_path	Path to repository TYPE:Path
period	Time period to analyze TYPE:strDEFAULT:'last-month'
config	Optional configuration TYPE:Optional[TenetsConfig]DEFAULT:None
**kwargs	Additional arguments for tracker DEFAULT:{}

RETURNS	DESCRIPTION
MomentumReport	Momentum analysis TYPE:MomentumReport

track_team_velocity

Python

track_team_velocity(repo_path: Path, period: str = 'last-month', team_mapping: Optional[Dict[str, List[str]]] = None, config: Optional[TenetsConfig] = None) -> TeamMetrics

Track team velocity metrics.

PARAMETER	DESCRIPTION
repo_path	Path to repository TYPE:Path
period	Time period to analyze TYPE:strDEFAULT:'last-month'
team_mapping	Team structure mapping TYPE:Optional[Dict[str, List[str]]]DEFAULT:None
config	Optional configuration TYPE:Optional[TenetsConfig]DEFAULT:None

RETURNS	DESCRIPTION
TeamMetrics	Team velocity metrics TYPE:TeamMetrics

analyze_sprint_velocity

Python

analyze_sprint_velocity(repo_path: Path, sprint_duration: int = 14, lookback_sprints: int = 6, config: Optional[Any] = None) -> SprintMetrics

Analyze velocity across recent sprints.

Calculates sprint-based velocity metrics to understand team performance and predictability over time.

PARAMETER	DESCRIPTION
repo_path	Path to git repository TYPE:Path
sprint_duration	Sprint length in days TYPE:intDEFAULT:14
lookback_sprints	Number of sprints to analyze TYPE:intDEFAULT:6
config	Optional TenetsConfig instance TYPE:Optional[Any]DEFAULT:None

RETURNS	DESCRIPTION
SprintMetrics	Sprint velocity analysis TYPE:SprintMetrics

Example

from tenets.core.momentum import analyze_sprint_velocity

metrics = analyze_sprint_velocity( ... Path("."), ... sprint_duration=14, ... lookback_sprints=6 ... ) print(f"Average velocity: {metrics.avg_velocity}")

analyze_team_productivity

Python

analyze_team_productivity(repo_path: Path, period: str = 'last-month', team_mapping: Optional[Dict[str, List[str]]] = None, config: Optional[Any] = None) -> TeamMetrics

Analyze team productivity metrics.

Provides detailed analysis of team productivity including individual contributions, collaboration patterns, and efficiency.

PARAMETER	DESCRIPTION
repo_path	Path to git repository TYPE:Path
period	Time period to analyze TYPE:strDEFAULT:'last-month'
team_mapping	Optional mapping of team names to members TYPE:Optional[Dict[str, List[str]]]DEFAULT:None
config	Optional TenetsConfig instance TYPE:Optional[Any]DEFAULT:None

RETURNS	DESCRIPTION
TeamMetrics	Team productivity analysis TYPE:TeamMetrics

Example

from tenets.core.momentum import analyze_team_productivity

team_metrics = analyze_team_productivity( ... Path("."), ... period="last-quarter", ... team_mapping={ ... "backend": ["alice@example.com", "bob@example.com"], ... "frontend": ["charlie@example.com", "diana@example.com"] ... } ... ) print(f"Team efficiency: {team_metrics.efficiency_score}")

predict_completion

Python

predict_completion(repo_path: Path, remaining_work: int, team_size: Optional[int] = None, confidence_level: float = 0.8, config: Optional[Any] = None) -> Dict[str, Any]

Predict project completion based on velocity.

Uses historical velocity data to predict when a certain amount of work will be completed.

PARAMETER	DESCRIPTION
repo_path	Path to git repository TYPE:Path
remaining_work	Estimated remaining work (in points/tasks) TYPE:int
team_size	Current team size (uses historical if not provided) TYPE:Optional[int]DEFAULT:None
confidence_level	Confidence level for prediction (0-1) TYPE:floatDEFAULT:0.8
config	Optional TenetsConfig instance TYPE:Optional[Any]DEFAULT:None

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Completion prediction including date and confidence

Example

from tenets.core.momentum import predict_completion

prediction = predict_completion( ... Path("."), ... remaining_work=100, ... team_size=5, ... confidence_level=0.8 ... ) print(f"Expected completion: {prediction['expected_date']}") print(f"Confidence: {prediction['confidence']}%")

calculate_burndown

Python

calculate_burndown(repo_path: Path, total_work: int, start_date: Optional[str] = None, end_date: Optional[str] = None, config: Optional[Any] = None) -> Dict[str, Any]

Calculate burndown chart data.

Generates data for burndown visualization showing work completion over time.

PARAMETER	DESCRIPTION
repo_path	Path to git repository TYPE:Path
total_work	Total work to complete TYPE:int
start_date	Sprint start date (ISO format) TYPE:Optional[str]DEFAULT:None
end_date	Sprint end date (ISO format) TYPE:Optional[str]DEFAULT:None
config	Optional TenetsConfig instance TYPE:Optional[Any]DEFAULT:None

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Burndown data including ideal and actual lines

Example

from tenets.core.momentum import calculate_burndown

burndown = calculate_burndown( ... Path("."), ... total_work=100, ... start_date="2024-01-01", ... end_date="2024-01-14" ... ) print(f"Completion: {burndown['completion_percentage']}%")

get_velocity_chart_data

Python

get_velocity_chart_data(repo_path: Path, period: str = 'last-quarter', interval: str = 'weekly', config: Optional[Any] = None) -> Dict[str, Any]

Get data for velocity chart visualization.

Prepares velocity data in a format suitable for charting, with configurable time intervals.

PARAMETER	DESCRIPTION
repo_path	Path to git repository TYPE:Path
period	Time period to analyze TYPE:strDEFAULT:'last-quarter'
interval	Data interval (daily, weekly, monthly) TYPE:strDEFAULT:'weekly'
config	Optional TenetsConfig instance TYPE:Optional[Any]DEFAULT:None

RETURNS	DESCRIPTION
Dict[str, Any]	Dict[str, Any]: Chart-ready velocity data

Example

from tenets.core.momentum import get_velocity_chart_data

chart_data = get_velocity_chart_data( ... Path("."), ... period="last-quarter", ... interval="weekly" ... )

Use chart_data for visualization

Modules

• metrics - Metrics module
• tracker - Tracker module