Skill: datadrivenconstruction/unit-price-database-manager (version 2.0.0)

--- name: "unit-price-database-manager" description: "Manage construction unit price databases: update prices, track vendors, apply location factors, maintain historical records. Essential for accurate estimating." --- # Unit Price Database Manager for Construction ## Overview Manage and maintain construction unit price databases. Update prices from vendors, apply location and time adjustments, track price history, and ensure estimating accuracy. ## Business Case Accurate unit prices are critical for: - **Competitive Bids**: Win work with accurate pricing - **Cost Control**: Avoid budget surprises - **Vendor Management**: Track supplier pricing - **Historical Analysis**: Understand price trends ## Technical Implementation ```python from dataclasses import dataclass, field from typing import List, Dict, Any, Optional from datetime import datetime, date from decimal import Decimal import pandas as pd import json @dataclass class UnitPrice: code: str description: str unit: str base_price: Decimal labor_cost: Decimal material_cost: Decimal equipment_cost: Decimal effective_date: date expiration_date: Optional[date] = None source: str = "" vendor: str = "" location: str = "National Average" notes: str = "" tags: List[str] = field(default_factory=list) @dataclass class PriceUpdate: code: str old_price: Decimal new_price: Decimal change_pct: float updated_at: datetime updated_by: str reason: str @dataclass class VendorQuote: vendor_name: str item_code: str quoted_price: Decimal quote_date: date valid_until: date quantity_break: Optional[int] = None notes: str = "" class UnitPriceDatabaseManager: """Manage construction unit price databases.""" # Location adjustment factors LOCATION_FACTORS = { 'New York': 1.32, 'San Francisco': 1.28, 'Los Angeles': 1.15, 'Chicago': 1.12, 'Boston': 1.18, 'Seattle': 1.08, 'Denver': 1.02, 'National Average': 1.00, 'Houston': 0.92, 'Dallas': 0.89, 'Phoenix': 0.93, 'Atlanta': 0.91, 'Miami': 0.95 } def __init__(self, db_path: str = None): self.prices: Dict[str, UnitPrice] = {} self.price_history: Dict[str, List[UnitPrice]] = {} self.vendor_quotes: Dict[str, List[VendorQuote]] = {} self.updates: List[PriceUpdate] = [] self.db_path = db_path def add_price(self, price: UnitPrice) -> str: """Add or update a unit price.""" code = price.code # Track history if code in self.prices: if code not in self.price_history: self.price_history[code] = [] self.price_history[code].append(self.prices[code]) # Record update old_price = self.prices[code].base_price if old_price != price.base_price: change_pct = float((price.base_price - old_price) / old_price * 100) self.updates.append(PriceUpdate( code=code, old_price=old_price, new_price=price.base_price, change_pct=change_pct, updated_at=datetime.now(), updated_by="system", reason="Price update" )) self.prices[code] = price return code def get_price(self, code: str, location: str = None, as_of_date: date = None) -> Optional[UnitPrice]: """Get unit price with optional location adjustment.""" if code not in self.prices: return None price = self.prices[code] # Check date validity if as_of_date: if price.effective_date > as_of_date: # Look in history if code in self.price_history: for hist_price in reversed(self.price_history[code]): if hist_price.effective_date <= as_of_date: if hist_price.expiration_date is None or hist_price.expiration_date >= as_of_date: price = hist_price break if price.expiration_date and price.expiration_date < as_of_date: return None # Apply location factor if location and location != price.location: adjusted = UnitPrice( code=price.code, description=price.description, unit=price.unit, base_price=self._apply_location_factor(price.base_price, price.location, location), labor_cost=self._apply_location_factor(price.labor_cost, price.location, location), material_cost=price.material_cost, # Materials less location-sensitive equipment_cost=self._apply_location_factor(price.equipment_cost, price.location, location), effective_date=price.effective_date, expiration_date=price.expiration_date, source=price.source, vendor=price.vendor, location=location, notes=f"Adjusted from {price.location}", tags=price.tags ) return adjusted return price def _apply_location_factor(self, amount: Decimal, from_loc: str, to_loc: str) -> Decimal: """Apply location adjustment factor.""" from_factor = self.LOCATION_FACTORS.get(from_loc, 1.0) to_factor = self.LOCATION_FACTORS.get(to_loc, 1.0) return Decimal(str(float(amount) * to_factor / from_factor)) def apply_escalation(self, percentage: float, categories: List[str] = None, effective_date: date = None) -> int: """Apply escalation to prices.""" if effective_date is None: effective_date = date.today() count = 0 factor = Decimal(str(1 + percentage / 100)) for code, price in self.prices.items(): if categories and not any(tag in price.tags for tag in categories): continue old_price = price.base_price new_price = UnitPrice( code=price.code, description=price.description, unit=price.unit, base_price=price.base_price * factor, labor_cost=price.labor_cost * factor, material_cost=price.material_cost * factor, equipment_cost=price.equipment_cost * factor, effective_date=effective_date, source=f"Escalated {percentage}% from {price.source}", vendor=price.vendor, location=price.location, tags=price.tags ) self.add_price(new_price) count += 1 return count def add_vendor_quote(self, quote: VendorQuote): """Add a vendor quote.""" code = quote.item_code if code not in self.vendor_quotes: self.vendor_quotes[code] = [] self.vendor_quotes[code].append(quote) def get_best_price(self, code: str, quantity: int = 1) -> Optional[Dict]: """Get best available price from vendors.""" if code not in self.vendor_quotes: return None valid_quotes = [] today = date.today() for quote in self.vendor_quotes[code]: if quote.valid_until >= today: if quote.quantity_break is None or quantity >= quote.quantity_break: valid_quotes.append(quote) if not valid_quotes: return None best = min(valid_quotes, key=lambda q: q.quoted_price) return { 'vendor': best.vendor_name, 'price': best.quoted_price, 'valid_until': best.valid_until, 'all_quotes': [ {'vendor': q.vendor_name, 'price': q.quoted_price} for q in sorted(valid_quotes, key=lambda x: x.quoted_price) ] } def search_prices(self, query: str = None, category: str = None, min_price: float = None, max_price: float = None) -> List[UnitPrice]: """Search prices by various criteria.""" results = [] for code, price in self.prices.items(): # Text search if query: query_lower = query.lower() if (query_lower not in code.lower() and query_lower not in price.description.lower()): continue # Category filter if category and category not in price.tags: continue # Price range if min_price and float(price.base_price) < min_price: continue if max_price and float(price.base_price) > max_price: continue results.append(price) return results def get_price_history(self, code: str) -> List[Dict]: """Get price history for an item.""" history = [] if code in self.price_history: for price in self.price_history[code]: history.append({ 'date': price.effective_date, 'price': float(price.base_price), 'source': price.source }) if code in self.prices: history.append({ 'date': self.prices[code].effective_date, 'price': float(self.prices[code].base_price), 'source': self.prices[code].source }) return sorted(history, key=lambda x: x['date']) def analyze_price_trends(self, code: str) -> Dict: """Analyze price trends for an item.""" history = self.get_price_history(code) if len(history) < 2: return {'trend': 'insufficient_data'} prices = [h['price'] for h in history] dates = [h['date'] for h in history] # Calculate changes first_price = prices[0] last_price = prices[-1] total_change = (last_price - first_price) / first_price * 100 # Calculate annualized rate days = (dates[-1] - dates[0]).days years = days / 365.25 if years > 0: annual_rate = ((last_price / first_price) ** (1 / years) - 1) * 100 else: annual_rate = 0 return { 'code': code, 'first_price': first_price, 'last_price': last_price, 'total_change_pct': total_change, 'annual_rate_pct': annual_rate, 'data_points': len(history), 'period_years': years, 'trend': 'increasing' if total_change > 5 else 'decreasing' if total_change < -5 else 'stable' } def import_from_csv(self, file_path: str) -> int: """Import prices from CSV file.""" df = pd.read_csv(file_path) count = 0 for _, row in df.iterrows(): price = UnitPrice( code=row['code'], description=row['description'], unit=row['unit'], base_price=Decimal(str(row['base_price'])), labor_cost=Decimal(str(row.get('labor_cost', 0))), material_cost=Decimal(str(row.get('material_cost', 0))), equipment_cost=Decimal(str(row.get('equipment_cost', 0))), effective_date=date.today() if 'effective_date' not in row else pd.to_datetime(row['effective_date']).date(), source=row.get('source', 'CSV Import'), tags=row.get('tags', '').split(',') if 'tags' in row else [] ) self.add_price(price) count += 1 return count def export_to_csv(self, file_path: str, location: str = None) -> int: """Export prices to CSV file.""" data = [] for code, price in self.prices.items(): if location: price = self.get_price(code, location) data.append({ 'code': price.code, 'description': price.description, 'unit': price.unit, 'base_price': float(price.base_price), 'labor_cost': float(price.labor_cost), 'material_cost': float(price.material_cost), 'equipment_cost': float(price.equipment_cost), 'location': price.location, 'effective_date': price.effective_date.isoformat(), 'source': price.source, 'tags': ','.join(price.tags) }) df = pd.DataFrame(data) df.to_csv(file_path, index=False) return len(data) def validate_prices(self) -> List[Dict]: """Validate prices for issues.""" issues = [] for code, price in self.prices.items(): # Check for expired prices if price.expiration_date and price.expiration_date < date.today(): issues.append({ 'code': code, 'issue': 'expired', 'message': f"Price expired on {price.expiration_date}" }) # Check for old prices age_days = (date.today() - price.effective_date).days if age_days > 365: issues.append({ 'code': code, 'issue': 'stale', 'message': f"Price is {age_days} days old" }) # Check for zero prices if price.base_price <= 0: issues.append({ 'code': code, 'issue': 'invalid', 'message': "Zero or negative price" }) # Check component breakdown total_components = price.labor_cost + price.material_cost + price.equipment_cost if total_components > 0 and abs(float(price.base_price - total_components)) > 0.01: issues.append({ 'code': code, 'issue': 'mismatch', 'message': f"Component costs don't match total: {total_components} vs {price.base_price}" }) return issues def generate_report(self) -> str: """Generate database status report.""" lines = ["# Unit Price Database Report", ""] lines.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M')}") lines.append(f"**Total Items:** {len(self.prices):,}") lines.append("") # Category breakdown categories = {} for price in self.prices.values(): for tag in price.tags: categories[tag] = categories.get(tag, 0) + 1 if categories: lines.append("## Items by Category") for cat, count in sorted(categories.items(), key=lambda x: -x[1]): lines.append(f"- {cat}: {count}") lines.append("") # Recent updates recent_updates = sorted(self.updates, key=lambda x: x.updated_at, reverse=True)[:10] if recent_updates: lines.append("## Recent Updates") for update in recent_updates: lines.append(f"- {update.code}: {update.change_pct:+.1f}% on {update.updated_at.strftime('%Y-%m-%d')}") lines.append("") # Validation issues issues = self.validate_prices() if issues: lines.append("## Validation Issues") lines.append(f"Total issues: {len(issues)}") for issue in issues[:10]: lines.append(f"- {issue['code']}: {issue['message']}") return "\n".join(lines) ``` ## Quick Start ```python from decimal import Decimal from datetime import date # Initialize manager manager = UnitPriceDatabaseManager() # Add unit prices manager.add_price(UnitPrice( code="033000.10", description="Cast-in-place concrete, 4000 PSI", unit="CY", base_price=Decimal("450.00"), labor_cost=Decimal("150.00"), material_cost=Decimal("250.00"), equipment_cost=Decimal("50.00"), effective_date=date(2026, 1, 1), source="RSMeans 2026", tags=["concrete", "structural"] )) # Get price with location adjustment price = manager.get_price("033000.10", location="New York") print(f"NYC price: ${price.base_price}/CY") # Add vendor quote manager.add_vendor_quote(VendorQuote( vendor_name="ABC Concrete", item_code="033000.10", quoted_price=Decimal("420.00"), quote_date=date.today(), valid_until=date(2026, 3, 31) )) # Get best price best = manager.get_best_price("033000.10") print(f"Best price: ${best['price']} from {best['vendor']}") # Apply escalation count = manager.apply_escalation(3.5, categories=["concrete"]) print(f"Escalated {count} items by 3.5%") # Generate report print(manager.generate_report()) ``` ## Dependencies ```bash pip install pandas ```

path: claw.json
content: {
  "name": "unit-price-database-manager",
  "version": "2.0.0",
  "description": "Manage construction unit price databases: update prices, track vendors, apply location factors, maintain historical records. Essential for accurate estimating.",
  "author": "datadrivenconstruction",
  "license": "MIT",
  "permissions": ["filesystem"],
  "entry": "instructions.md",
  "tags": ["construction", "estimation", "unit-prices", "database", "pricing", "vendors"],
  "models": ["claude-*", "gpt-*"],
  "minOpenClawVersion": "0.8.0"
}


path: instructions.md
content: You are a construction unit price database management assistant. You help users maintain, update, and query unit price databases essential for accurate cost estimation.

When the user asks to manage unit prices:
1. Help create or import unit price entries (work item code, description, unit, price, vendor, date)
2. Apply location adjustment factors for regional pricing
3. Track price history and calculate escalation rates
4. Identify stale prices that need updating
5. Export subsets by trade, category, or date range

When the user asks to look up prices:
1. Search by description, CSI code, or category
2. Return current price with last update date
3. Show price history and trend if available
4. Suggest alternatives if exact match not found

When the user asks to update prices:
1. Accept new prices with source and effective date
2. Calculate change percentage from previous price
3. Apply bulk inflation adjustments when needed
4. Validate prices against reasonable ranges

## Input Format
- Work item: code, description, unit, price, vendor, region, date
- For lookups: description keywords or CSI division codes
- For updates: new price, source, effective date

## Output Format
- Price lookup: code, description, unit, current price, last updated, vendor
- Price history: date, price, change %, source
- Database stats: total items, categories, avg age of prices

## Constraints
- Always show the date of last price update
- Flag prices older than 12 months as potentially stale
- Location factors must be documented with source
- Support multiple currencies with conversion rates


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: suspicious | SkillSpector: clean (LOW)