Skip to content

warranty-tracker

Track and manage construction warranties. Monitor expiration dates, claims, and manufacturer documentation.

986
installs
0 up / 0 down, score 0.00
votes
358
repo stars
Updated
less than a month ago
In the catalog since
6 Oct 2026
From
datadrivenconstruction/ddc_skills_for_ai_agents_in_construction
Project Management
Get it through your agent npx skills add datadrivenconstruction/ddc_skills_for_ai_agents_in_construction@warranty-tracker

Skill instructions

Rendered from the published SKILL.md, 441 lines.

Warranty Tracker

Business Case

Problem Statement

Warranty management is often neglected:

  • Missing warranty documentation
  • Expired warranties untracked
  • Difficult to file claims
  • Scattered across multiple files

Solution

Centralized warranty tracking system that monitors expiration dates, stores documentation, and manages claims.

Business Value

  • Cost savings - File claims before expiration
  • Organization - Central warranty repository
  • Compliance - Meet handover requirements
  • Proactive - Automatic expiration alerts

Technical Implementation

import pandas as pd
from datetime import datetime, date, timedelta
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from enum import Enum


class WarrantyType(Enum):
    """Types of warranties."""
    MANUFACTURER = "manufacturer"
    CONTRACTOR = "contractor"
    INSTALLER = "installer"
    EXTENDED = "extended"
    PERFORMANCE = "performance"


class WarrantyStatus(Enum):
    """Warranty status."""
    ACTIVE = "active"
    EXPIRING_SOON = "expiring_soon"  # Within 90 days
    EXPIRED = "expired"
    CLAIMED = "claimed"
    VOID = "void"


class ClaimStatus(Enum):
    """Warranty claim status."""
    DRAFT = "draft"
    SUBMITTED = "submitted"
    UNDER_REVIEW = "under_review"
    APPROVED = "approved"
    DENIED = "denied"
    RESOLVED = "resolved"


class BuildingSystem(Enum):
    """Building systems."""
    STRUCTURAL = "structural"
    ROOFING = "roofing"
    HVAC = "hvac"
    ELECTRICAL = "electrical"
    PLUMBING = "plumbing"
    ELEVATORS = "elevators"
    FIRE_PROTECTION = "fire_protection"
    GLAZING = "glazing"
    FLOORING = "flooring"
    PAINTING = "painting"
    APPLIANCES = "appliances"
    EXTERIOR = "exterior"
    OTHER = "other"


@dataclass
class WarrantyDocument:
    """Warranty document reference."""
    document_id: str
    filename: str
    document_type: str  # certificate, manual, conditions
    upload_date: date
    file_path: str


@dataclass
class Warranty:
    """Warranty record."""
    warranty_id: str
    item_description: str
    system: BuildingSystem
    warranty_type: WarrantyType
    manufacturer: str
    contractor: str
    start_date: date
    end_date: date
    duration_years: int
    coverage_details: str
    exclusions: str
    contact_name: str
    contact_phone: str
    contact_email: str
    location: str
    documents: List[WarrantyDocument] = field(default_factory=list)
    notes: str = ""

    @property
    def status(self) -> WarrantyStatus:
        """Calculate current warranty status."""
        today = date.today()
        if today > self.end_date:
            return WarrantyStatus.EXPIRED
        elif (self.end_date - today).days <= 90:
            return WarrantyStatus.EXPIRING_SOON
        else:
            return WarrantyStatus.ACTIVE

    @property
    def days_remaining(self) -> int:
        """Days until warranty expires."""
Show the whole skill (321 more lines) 
    return (self.end_date - date.today()).days

def to_dict(self) -> Dict[str, Any]:
    return {
        'warranty_id': self.warranty_id,
        'item': self.item_description,
        'system': self.system.value,
        'type': self.warranty_type.value,
        'manufacturer': self.manufacturer,
        'contractor': self.contractor,
        'start_date': self.start_date.isoformat(),
        'end_date': self.end_date.isoformat(),
        'duration_years': self.duration_years,
        'status': self.status.value,
        'days_remaining': self.days_remaining,
        'contact': self.contact_email
    }

@dataclass class WarrantyClaim: """Warranty claim record.""" claim_id: str warranty_id: str issue_description: str issue_date: date reported_date: date status: ClaimStatus reported_by: str resolution: str = "" resolution_date: Optional[date] = None cost_covered: float = 0.0 documents: List[str] = field(default_factory=list) notes: str = ""

class WarrantyTracker: """Track and manage construction warranties."""

EXPIRING_THRESHOLD_DAYS = 90

def __init__(self, project_name: str, substantial_completion_date: date):
    self.project_name = project_name
    self.completion_date = substantial_completion_date
    self.warranties: Dict[str, Warranty] = {}
    self.claims: Dict[str, WarrantyClaim] = {}
    self._warranty_counter = 0
    self._claim_counter = 0

def add_warranty(self,
                item_description: str,
                system: BuildingSystem,
                warranty_type: WarrantyType,
                manufacturer: str,
                contractor: str,
                duration_years: int,
                coverage_details: str,
                contact_email: str,
                start_date: date = None,
                contact_name: str = "",
                contact_phone: str = "",
                exclusions: str = "",
                location: str = "") -> Warranty:
    """Add new warranty record."""
    self._warranty_counter += 1
    warranty_id = f"WRT-{self._warranty_counter:04d}"

    start = start_date or self.completion_date
    end = start + timedelta(days=duration_years * 365)

    warranty = Warranty(
        warranty_id=warranty_id,
        item_description=item_description,
        system=system,
        warranty_type=warranty_type,
        manufacturer=manufacturer,
        contractor=contractor,
        start_date=start,
        end_date=end,
        duration_years=duration_years,
        coverage_details=coverage_details,
        exclusions=exclusions,
        contact_name=contact_name,
        contact_phone=contact_phone,
        contact_email=contact_email,
        location=location
    )

    self.warranties[warranty_id] = warranty
    return warranty

def add_document(self, warranty_id: str,
                filename: str,
                document_type: str,
                file_path: str) -> WarrantyDocument:
    """Add document to warranty."""
    if warranty_id not in self.warranties:
        raise ValueError(f"Warranty {warranty_id} not found")

    doc_id = f"{warranty_id}-DOC-{len(self.warranties[warranty_id].documents) + 1:02d}"
    document = WarrantyDocument(
        document_id=doc_id,
        filename=filename,
        document_type=document_type,
        upload_date=date.today(),
        file_path=file_path
    )

    self.warranties[warranty_id].documents.append(document)
    return document

def file_claim(self,
              warranty_id: str,
              issue_description: str,
              issue_date: date,
              reported_by: str) -> WarrantyClaim:
    """File warranty claim."""
    if warranty_id not in self.warranties:
        raise ValueError(f"Warranty {warranty_id} not found")

    warranty = self.warranties[warranty_id]

    # Check if warranty is active
    if warranty.status == WarrantyStatus.EXPIRED:
        raise ValueError(f"Warranty {warranty_id} has expired")

    self._claim_counter += 1
    claim_id = f"CLM-{self._claim_counter:04d}"

    claim = WarrantyClaim(
        claim_id=claim_id,
        warranty_id=warranty_id,
        issue_description=issue_description,
        issue_date=issue_date,
        reported_date=date.today(),
        status=ClaimStatus.DRAFT,
        reported_by=reported_by
    )

    self.claims[claim_id] = claim
    return claim

def update_claim_status(self, claim_id: str,
                       status: ClaimStatus,
                       resolution: str = "",
                       cost_covered: float = 0.0):
    """Update claim status."""
    if claim_id not in self.claims:
        raise ValueError(f"Claim {claim_id} not found")

    claim = self.claims[claim_id]
    claim.status = status

    if resolution:
        claim.resolution = resolution

    if cost_covered > 0:
        claim.cost_covered = cost_covered

    if status in [ClaimStatus.APPROVED, ClaimStatus.DENIED, ClaimStatus.RESOLVED]:
        claim.resolution_date = date.today()

def get_expiring_warranties(self, days: int = None) -> List[Warranty]:
    """Get warranties expiring within specified days."""
    threshold = days or self.EXPIRING_THRESHOLD_DAYS
    cutoff = date.today() + timedelta(days=threshold)

    return [w for w in self.warranties.values()
            if w.status == WarrantyStatus.ACTIVE and w.end_date <= cutoff]

def get_active_warranties(self) -> List[Warranty]:
    """Get all active warranties."""
    return [w for w in self.warranties.values()
            if w.status in [WarrantyStatus.ACTIVE, WarrantyStatus.EXPIRING_SOON]]

def get_warranties_by_system(self, system: BuildingSystem) -> List[Warranty]:
    """Get warranties for specific building system."""
    return [w for w in self.warranties.values() if w.system == system]

def get_summary(self) -> Dict[str, Any]:
    """Generate warranty summary."""
    by_status = {}
    by_system = {}

    for warranty in self.warranties.values():
        # By status
        status = warranty.status.value
        by_status[status] = by_status.get(status, 0) + 1

        # By system
        system = warranty.system.value
        by_system[system] = by_system.get(system, 0) + 1

    # Claims summary
    open_claims = sum(1 for c in self.claims.values()
                    if c.status not in [ClaimStatus.RESOLVED, ClaimStatus.DENIED])
    total_covered = sum(c.cost_covered for c in self.claims.values()
                      if c.status == ClaimStatus.RESOLVED)

    return {
        'total_warranties': len(self.warranties),
        'by_status': by_status,
        'by_system': by_system,
        'expiring_soon': len(self.get_expiring_warranties()),
        'total_claims': len(self.claims),
        'open_claims': open_claims,
        'total_cost_recovered': total_covered,
        'project': self.project_name,
        'completion_date': self.completion_date.isoformat()
    }

def generate_expiration_report(self, months_ahead: int = 12) -> pd.DataFrame:
    """Generate warranty expiration report."""
    cutoff = date.today() + timedelta(days=months_ahead * 30)
    upcoming = [w for w in self.warranties.values() if w.end_date <= cutoff]

    data = []
    for w in sorted(upcoming, key=lambda x: x.end_date):
        data.append({
            'Warranty ID': w.warranty_id,
            'Item': w.item_description,
            'System': w.system.value,
            'Manufacturer': w.manufacturer,
            'End Date': w.end_date,
            'Days Remaining': w.days_remaining,
            'Status': w.status.value,
            'Contact': w.contact_email
        })

    return pd.DataFrame(data)

def export_to_excel(self, output_path: str):
    """Export all warranty data to Excel."""
    with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
        # Warranties
        warranties_df = pd.DataFrame([w.to_dict() for w in self.warranties.values()])
        if not warranties_df.empty:
            warranties_df.to_excel(writer, sheet_name='Warranties', index=False)

        # Claims
        claims_data = []
        for claim in self.claims.values():
            warranty = self.warranties.get(claim.warranty_id)
            claims_data.append({
                'Claim ID': claim.claim_id,
                'Warranty ID': claim.warranty_id,
                'Item': warranty.item_description if warranty else '',
                'Issue': claim.issue_description,
                'Issue Date': claim.issue_date,
                'Status': claim.status.value,
                'Resolution': claim.resolution,
                'Cost Covered': claim.cost_covered
            })

        if claims_data:
            pd.DataFrame(claims_data).to_excel(writer, sheet_name='Claims', index=False)

        # Expiring soon
        expiring = self.generate_expiration_report(6)
        if not expiring.empty:
            expiring.to_excel(writer, sheet_name='Expiring Soon', index=False)

    return output_path


## Quick Start

```python
from datetime import date

# Initialize tracker
tracker = WarrantyTracker(
    project_name="Office Tower",
    substantial_completion_date=date(2024, 6, 1)
)

# Add warranties
tracker.add_warranty(
    item_description="HVAC System - Rooftop Units",
    system=BuildingSystem.HVAC,
    warranty_type=WarrantyType.MANUFACTURER,
    manufacturer="Carrier",
    contractor="ABC Mechanical",
    duration_years=5,
    coverage_details="Parts and labor for manufacturing defects",
    contact_email="warranty@carrier.com"
)

# Check expiring warranties
expiring = tracker.get_expiring_warranties(90)
print(f"Warranties expiring in 90 days: {len(expiring)}")

Common Use Cases

1. Monthly Review

# Get expiration report
report = tracker.generate_expiration_report(months_ahead=3)
print(report[['Item', 'End Date', 'Days Remaining']])

2. File Claim

claim = tracker.file_claim(
    warranty_id="WRT-0001",
    issue_description="RTU-1 compressor failure",
    issue_date=date.today(),
    reported_by="Building Manager"
)

3. Export for Handover

tracker.export_to_excel("warranty_register.xlsx")

Resources

  • DDC Book: Chapter 5 - Project Closeout
  • Reference: AIA Document G714