К основному содержанию
скилл CX Codex

auto-estimate-generator — скилл для Claude Code: генерация смет из BIM

Скилл auto-estimate-generator для Claude Code автоматически создаёт сметы по данным BIM и QTO, сопоставляя количества с правилами ценообразования. Требует Python3.

MIT 124 установок ★ 434 обновлён 2026-10-19

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill auto-estimate-generator -a claude-code
Открыть на GitHub

Что делает auto-estimate-generator

Скилл берёт количества элементов из QTO (количественного учёта), сопоставляет их с правилами ценообразования и выдаёт готовую смету с разбивкой по элементам и типам. Внутри — классификация элементов (стены, полы, окна, двери, колонны, балки, фундаменты, кровля, лестницы, инженерные системы), поддержка условных правил (по материалу, толщине), расчёт затрат с разделением на труд, материалы и оборудование.

Скилл загружает данные из таблиц (pandas), сопоставляет QTO-элементы с наиболее специфичным подходящим правилом, вычисляет итоговую стоимость и показывает, какие позиции не удалось спарить. Требует Python3 в PATH.

Какие задачи решает

  • сопоставить количества BIM с прайс-листами и правилами
  • пересчитать сметы при изменении цен или объёмов
  • найти элементы, не охваченные ценовыми правилами
  • разбить стоимость по типам затрат и сметным единицам
  • автоматизировать расчёт сметной стоимости проекта

Примеры запросов агенту

  • Сгенерируй смету из QTO с правилами по материалам и толщинам
  • Посчитай стоимость по типам элементов и покажи, что не спарилось
  • Загрузи таблицу с количествами и примени ценовые правила автоматически

Как установить auto-estimate-generator

1Через Skills CLI (Vercel)

npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill auto-estimate-generator -a claude-code

2Вручную: положить файлы

~/.claude/skills/auto-estimate-generator/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/auto-estimate-generator/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы об auto-estimate-generator

Как установить auto-estimate-generator в Claude Code?

Выполни npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill auto-estimate-generator -a claude-code, затем открой конфигурацию в ~/.claude/skills/auto-estimate-generator/SKILL.md.

Что делает auto-estimate-generator?

Автоматически генерирует сметы из BIM и QTO данных, сопоставляя элементы с ценовыми правилами, рассчитывая стоимость и показывая несопоставленные позиции.

Какие данные нужны для работы скилла?

Таблицы с QTO-элементами (ID, тип, название, количество, единица, свойства) и ценовыми правилами (ID, название, тип элемента, условия, стоимость за единицу, разбивка затрат). Python3 должен быть установлен.

Исходный текст

SKILL.md · MIT
---
name: "auto-estimate-generator"
description: "Automatically generate estimates from QTO data. Apply pricing rules to BIM quantities for cost estimates."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw":{"emoji":"⚡","os":["darwin","linux","win32"],"homepage":"https://datadrivenconstruction.io","requires":{"bins":["python3"]}}}
---

# Auto Estimate Generator

## Business Case

### Problem Statement
Manual estimate creation challenges:
- Time-consuming quantity mapping
- Inconsistent pricing rules
- Errors in calculations
- Difficulty updating estimates

### Solution
Automated estimate generation from BIM/QTO data using configurable pricing rules and assembly mappings.

## Technical Implementation

```python
import pandas as pd
from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
from enum import Enum


class ElementType(Enum):
    WALL = "wall"
    FLOOR = "floor"
    CEILING = "ceiling"
    DOOR = "door"
    WINDOW = "window"
    COLUMN = "column"
    BEAM = "beam"
    FOUNDATION = "foundation"
    ROOF = "roof"
    STAIR = "stair"
    MEP = "mep"


@dataclass
class QTOItem:
    element_id: str
    element_type: ElementType
    name: str
    quantity: float
    unit: str
    properties: Dict[str, Any] = field(default_factory=dict)


@dataclass
class PricingRule:
    rule_id: str
    name: str
    element_type: ElementType
    conditions: Dict[str, Any] = field(default_factory=dict)
    unit_cost: float = 0
    assembly_code: str = ""
    cost_breakdown: Dict[str, float] = field(default_factory=dict)


@dataclass
class EstimateItem:
    qto_element_id: str
    description: str
    quantity: float
    unit: str
    unit_cost: float
    total_cost: float
    rule_applied: str
    wbs_code: str = ""


class AutoEstimateGenerator:
    """Generate estimates from QTO data automatically."""

    def __init__(self, project_name: str):
        self.project_name = project_name
        self.pricing_rules: List[PricingRule] = []
        self.qto_items: List[QTOItem] = []
        self.estimate_items: List[EstimateItem] = []
        self.unmapped_items: List[QTOItem] = []

    def add_pricing_rule(self, rule: PricingRule):
        """Add pricing rule."""
        self.pricing_rules.append(rule)

    def load_pricing_rules_from_df(self, df: pd.DataFrame):
        """Load pricing rules from DataFrame."""

        for _, row in df.iterrows():
            conditions = {}
            if 'material' in row:
                conditions['material'] = row['material']
            if 'thickness_min' in row:
                conditions['thickness_min'] = row['thickness_min']
            if 'thickness_max' in row:
                conditions['thickness_max'] = row['thickness_max']

            rule = PricingRule(
                rule_id=row['rule_id'],
                name=row['name'],
                element_type=ElementType(row['element_type'].lower()),
                conditions=conditions,
                unit_cost=float(row['unit_cost']),
                assembly_code=row.get('assembly_code', ''),
                cost_breakdown={
                    'labor': float(row.get('labor_pct', 0.4)),
                    'material': float(row.get('material_pct', 0.5)),
                    'equipment': float(row.get('equipment_pct', 0.1))
                }
            )
            self.add_pricing_rule(rule)

    def load_qto_from_df(self, df: pd.DataFrame):
        """Load QTO items from DataFrame."""

        for _, row in df.iterrows():
            properties = {}
            for col in df.columns:
                if col not in ['element_id', 'element_type', 'name', 'quantity', 'unit']:
                    properties[col] = row[col]

            qto = QTOItem(
                element_id=str(row['element_id']),
                element_type=ElementType(row['element_type'].lower()),
                name=row['name'],
                quantity=float(row['quantity']),
                unit=row['unit'],
                properties=properties
            )
            self.qto_items.append(qto)

    def find_matching_rule(self, qto_item: QTOItem) -> Optional[PricingRule]:
        """Find pricing rule that matches QTO item."""

        matching_rules = []

        for rule in self.pricing_rules:
            if rule.element_type != qto_item.element_type:
                continue

            # Check conditions
            match = True
            for key, value in rule.conditions.items():
                if key.endswith('_min'):
                    prop_name = key[:-4]
                    if prop_name in qto_item.properties:
                        if qto_item.properties[prop_name] < value:
                            match = False
                elif key.endswith('_max'):
                    prop_name = key[:-4]
                    if prop_name in qto_item.properties:
                        if qto_item.properties[prop_name] > value:
                            match = False
                else:
                    if key in qto_item.properties:
                        if qto_item.properties[key] != value:
                            match = False

            if match:
                matching_rules.append(rule)

        # Return most specific rule (most conditions)
        if matching_rules:
            return max(matching_rules, key=lambda r: len(r.conditions))
        return None

    def generate_estimate(self) -> Dict[str, Any]:
        """Generate estimate from QTO items."""

        self.estimate_items = []
        self.unmapped_items = []
        total_cost = 0

        for qto in self.qto_items:
            rule = self.find_matching_rule(qto)

            if rule:
                item_cost = qto.quantity * rule.unit_cost

                self.estimate_items.append(EstimateItem(
                    qto_element_id=qto.element_id,
                    description=f"{qto.name} ({rule.name})",
                    quantity=qto.quantity,
                    unit=qto.unit,
                    unit_cost=rule.unit_cost,
                    total_cost=round(item_cost, 2),
                    rule_applied=rule.rule_id,
                    wbs_code=rule.assembly_code
                ))
                total_cost += item_cost
            else:
                self.unmapped_items.append(qto)

        return {
            'project': self.project_name,
            'total_qto_items': len(self.qto_items),
            'mapped_items': len(self.estimate_items),
            'unmapped_items': len(self.unmapped_items),
            'mapping_rate': round(len(self.estimate_items) / len(self.qto_items) * 100, 1) if self.qto_items else 0,
            'total_cost': round(total_cost, 2),
            'items': self.estimate_items
        }

    def get_cost_by_element_type(self) -> Dict[str, float]:
        """Get cost breakdown by element type."""

        by_type = {}
        for qto in self.qto_items:
            for est_item in self.estimate_items:
                if est_item.qto_element_id == qto.element_id:
                    type_name = qto.element_type.value
                    by_type[type_name] = by_type.get(type_name, 0) + est_item.total_cost

        return {k: round(v, 2) for k, v in by_type.items()}

    def get_unmapped_summary(self) -> pd.DataFrame:
        """Get summary of unmapped items."""

        if not self.unmapped_items:
            return pd.DataFrame()

        data = []
        for item in self.unmapped_items:
            data.append({
                'Element ID': item.element_id,
                'Type': item.element_type.value,
                'Name': item.name,
                'Quantity': item.quantity,
                'Unit': item.unit,
                'Properties': str(item.properties)
            })

        return pd.DataFrame(data)

    def export_to_excel(self, output_path: str) -> str:
        """Export estimate to Excel."""

        result = self.generate_estimate()

        with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
            # Summary
            summary_df = pd.DataFrame([{
                'Project': self.project_name,
                'Total QTO Items': result['total_qto_items'],
                'Mapped Items': result['mapped_items'],
                'Unmapped Items': result['unmapped_items'],
                'Mapping Rate %': result['mapping_rate'],
                'Total Cost': result['total_cost']
            }])
            summary_df.to_excel(writer, sheet_name='Summary', index=False)

            # Estimate items
            items_df = pd.DataFrame([{
                'Element ID': item.qto_element_id,
                'Description': item.description,
                'Quantity': item.quantity,
                'Unit': item.unit,
                'Unit Cost': item.unit_cost,
                'Total Cost': item.total_cost,
                'WBS': item.wbs_code,
                'Rule': item.rule_applied
            } for item in self.estimate_items])
            items_df.to_excel(writer, sheet_name='Estimate', index=False)

            # By element type
            by_type_df = pd.DataFrame([
                {'Element Type': k, 'Cost': v}
                for k, v in self.get_cost_by_element_type().items()
            ])
            by_type_df.to_excel(writer, sheet_name='By Type', index=False)

            # Unmapped items
            unmapped_df = self.get_unmapped_summary()
            if not unmapped_df.empty:
                unmapped_df.to_excel(writer, sheet_name='Unmapped', index=False)

        return output_path

    def suggest_missing_rules(self) -> List[Dict[str, Any]]:
        """Suggest pricing rules for unmapped items."""

        suggestions = []
        seen_types = set()

        for item in self.unmapped_items:
            key = (item.element_type.value, str(item.properties))
            if key not in seen_types:
                seen_types.add(key)
                suggestions.append({
                    'element_type': item.element_type.value,
                    'sample_name': item.name,
                    'properties': item.properties,
                    'count': sum(1 for i in self.unmapped_items
                                if i.element_type == item.element_type
                                and str(i.properties) == str(item.properties))
                })

        return sorted(suggestions, key=lambda x: x['count'], reverse=True)
```

## Quick Start

```python
# Initialize generator
generator = AutoEstimateGenerator("Office Building A")

# Add pricing rules
generator.add_pricing_rule(PricingRule(
    rule_id="W-001",
    name="Interior Wall - Drywall",
    element_type=ElementType.WALL,
    conditions={"material": "Drywall"},
    unit_cost=45.00,
    assembly_code="09.29.10"
))

generator.add_pricing_rule(PricingRule(
    rule_id="W-002",
    name="Exterior Wall - Masonry",
    element_type=ElementType.WALL,
    conditions={"material": "Masonry"},
    unit_cost=125.00,
    assembly_code="04.21.13"
))

# Load QTO data
generator.qto_items = [
    QTOItem("W-001", ElementType.WALL, "Interior Wall L1", 500, "SF", {"material": "Drywall"}),
    QTOItem("W-002", ElementType.WALL, "Exterior Wall", 1200, "SF", {"material": "Masonry"})
]

# Generate estimate
result = generator.generate_estimate()
print(f"Total Cost: ${result['total_cost']:,.2f}")
print(f"Mapping Rate: {result['mapping_rate']}%")
```

## Common Use Cases

### 1. Cost by Element Type
```python
by_type = generator.get_cost_by_element_type()
for element_type, cost in by_type.items():
    print(f"{element_type}: ${cost:,.2f}")
```

### 2. Unmapped Items
```python
unmapped = generator.get_unmapped_summary()
print(unmapped)
```

### 3. Rule Suggestions
```python
suggestions = generator.suggest_missing_rules()
for s in suggestions:
    print(f"Need rule for: {s['element_type']} ({s['count']} items)")
```

## Resources
- **DDC Book**: Chapter 3.2 - QTO and Automated Estimates
- **Website**: https://datadrivenconstruction.io

© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction

Похожие скиллы

Все скиллы по теме «ИИ и ML» →
construction-expert personamanagmentlayer Скилл construction-expert настраивает агента на задачи строительного инжиниринга: управление проектами, контроль безопасности по нормам OSHA и работу со стандартами BIM. CX Codex +1 667установок estimate-analysis himself65 Скилл estimate-analysis для Claude Code собирает консенсус-оценки аналитиков по тикеру из Yahoo Finance и отслеживает динамику ревизий за 7, 30, 60 и 90 дней. CX Codex +1 3 600установок agent-estimate kiloloop Плагин agent-estimate для Claude Code оценивает сроки задач для ИИ-агентов методом PERT. Он сравнивает прогноз с человеческим темпом и проверяет надёжность выбранной модели. ★ 7звёзд репо implement-paper-auto marimo-team Скилл implement-paper-auto для Claude Code превращает исследовательскую статью в интерактивный ноутбук marimo. Он сам выбирает идею для демонстрации и не запрашивает уточнений. CX Codex +1 2 400установок Python Auto Typer with Customizable Delay [email protected] Промпт Python Auto Typer with Customizable Delay для ChatGPT, Claude.ai и Claude Code создаёт десктопное приложение на Python с графическим интерфейсом для автоматического ввода текста. Код настраивает задержку и сборку в exe-файл Windows. GP ChatGPT ★ 178 201звёзд репо aibijia-price-comparison reason-machines Скилл aibijia-price-comparison помогает настроить сбор и сравнение цен на токены нейросетей и ключи подписок с площадок реселлеров. Пригодится при поиске дешёвых аккаунтов. CX Codex +1 287установок

Из того же набора156

Весь набор →
image-to-data Скилл image-to-data анализирует строительные фотографии, отсканированные документы и чертежи, извлекает из них текст, таблицы и объекты через компьютерное зрение и OCR. CX Codex +1 125установок xml-reader Скилл xml-reader для Claude Code, Cursor, Codex и других платформ читает XML из P6, IFC, COBie и buildingSMART Data Dictionary. Превращает элементы в pandas DataFrames. CX Codex +1 125установок cwicr-quantity-matcher Скилл cwicr-quantity-matcher сопоставляет количества элементов BIM с позициями CWICR по категориям и описаниям. Помогает связать ведомость объёмов с кодами работ и проверить соответствия. CX Codex +1 125установок as-built-documentation Скилл as-built-documentation структурирует исполнительную документацию и готовит цифровую сдачу строительного объекта. Проверяет комплектность чертежей, паспортов и руководств перед передачей в эксплуатацию. CX Codex +1 124установок cashflow-forecaster Скилл cashflow-forecaster прогнозирует денежные потоки стройпроекта: считает разрывы между затратами и платежами от заказчика, показывает, когда потребуется финансирование. CX Codex +1 124установок n8n-project-management Скилл n8n-project-management для построения системы управления строительными проектами с ботом Telegram, распределением задач и фотоотчётами через n8n. Требует Python 3 и доступ к Google Sheets. CX Codex +1 124установок material-procurement-tracker Скилл material-procurement-tracker помогает вести закупки материалов от заявки до поставки: считает сроки заказа, отмечает просрочки и сводит позиции по статусам и стоимости. CX Codex +1 124установок environmental-monitoring Скилл environmental-monitoring отслеживает шум и запылённость на стройплощадке через датчики. Он сверяет показатели с лимитами OSHA, EPA и DIN 4150 для защиты рабочих. CX Codex +1 124установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой