@structupath/pi-steel 0.2.2 → 0.2.3

package/skills/steel-rfq/scripts/recalc.py

@@ -21,14 +21,23 @@ import sys
 import tempfile
 
 
+class RecalculationError(RuntimeError):
+    """Raised when recalculate-on-open cannot be recorded safely."""
+
+
 def flag_recalc_on_load(path):
     import openpyxl
-    wb = openpyxl.load_workbook(path)
+
     try:
+        wb = openpyxl.load_workbook(path)
         wb.calculation.fullCalcOnLoad = True
-    except Exception:
-        pass  # older openpyxl — the LibreOffice bake below still fixes values
-    wb.save(path)
+        wb.calculation.forceFullCalc = True
+        wb.calculation.calcMode = "auto"
+        wb.save(path)
+    except Exception as exc:
+        raise RecalculationError(
+            f"could not record recalculate-on-open state for {path}: {exc}"
+        ) from exc
 
 
 def libreoffice_bake(path):
@@ -52,22 +61,36 @@ def libreoffice_bake(path):
     return False
 
 
+def recalculate(path, *, bake=True):
+    """Set recalc-on-open and return an honest cache status."""
+    flag_recalc_on_load(path)
+    if bake and libreoffice_bake(path):
+        return "baked_via_libreoffice"
+    return "deferred_recalculate_on_open"
+
+
 def main():
     if len(sys.argv) < 2:
-        sys.exit("usage: python3 recalc.py <workbook.xlsx>")
+        print("usage: python3 recalc.py <workbook.xlsx>", file=sys.stderr)
+        return 1
     path = sys.argv[1]
     if not os.path.exists(path):
-        sys.exit(f"file not found: {path}")
+        print(f"file not found: {path}", file=sys.stderr)
+        return 1
     # Set recalc-on-open FIRST so LibreOffice honors it, then bake. Do NOT
     # reload with openpyxl afterward — that would strip the cached values
     # LibreOffice just computed.
-    flag_recalc_on_load(path)
-    baked = libreoffice_bake(path)
-    if baked:
+    try:
+        status = recalculate(path)
+    except RecalculationError as exc:
+        print(f"recalc: failed — {exc}", file=sys.stderr)
+        return 1
+    if status == "baked_via_libreoffice":
         print(f"recalc: values computed and baked via LibreOffice — {path}")
     else:
         print(f"recalc: recalc-on-open set (open in Excel to compute values) — {path}")
+    return 0
 
 
 if __name__ == "__main__":
-    main()
+    raise SystemExit(main())

package/skills/steel-takeoff/SKILL.md

@@ -13,14 +13,14 @@ compatibility: Requires jq and python3. macOS or Linux.
 metadata:
   domain: structural-steel
   version: "1.0.0"
-  aisc-edition: "16th"
-  shapes-count: "400+"
+  dataset: "StructuPath Structural Shapes Database"
+  shapes-count: "477"
 allowed-tools: Bash Read Edit Write
 ---
 
 # Steel Takeoff Skill
 
-Structural steel quantity takeoff and AISC member data lookup using the 16th Edition shapes database.
+Structural steel quantity takeoff and member data lookup using StructuPath's 477-shape database.
 
 ## Setup (run once per machine)
 
@@ -31,9 +31,9 @@ python3 -c "import json, csv, sys" || echo "ERROR: python3 required"
 command -v jq >/dev/null || echo "ERROR: install jq (brew install jq / apt install jq)"
 ```
 
-## Quick Reference: AISC Member Lookup
+## Quick Reference: Structural Member Lookup
 
-Look up any AISC shape's full property set:
+Look up any supported shape's full property set:
 
 ```bash
 # Single member lookup — returns all properties
@@ -72,10 +72,12 @@ For each unique member mark, create a line item:
 cat assets/bom-template.csv
 ```
 
-Fields: Mark, Qty, Size, Grade, Length_ft, Unit_Wt_plf, Total_Wt_lbs, Connections, Notes
+Fields: Source_ID, Mark, Qty, Size, Grade, Length_ft, Unit_Wt_plf,
+Total_Wt_lbs, Connections, Notes, Source_Sheet, Source_Detail, Intent.
+Use stable synthetic or source-system IDs; do not invent drawing evidence.
 
 ### Step 3 — Look Up Unit Weights
-For every member size in the BOM, look up the unit weight from the AISC database:
+For every member size in the BOM, look up the unit weight from the bundled StructuPath database:
 
 ```bash
 ./scripts/lookup-member.sh "W14X30"
@@ -96,7 +98,9 @@ For every member size in the BOM, look up the unit weight from the AISC database
 #   Total weight in lbs and tons
 #   Connection allowance (12%)
 #   Misc steel allowance (5%)
-#   Grand total with estimated cost
+#   Grand total weight
+#   No pricing unless a separate project input supplies an explicit currency,
+#   unit basis, effective date, and source
 ```
 
 ### Step 5 — Add Connections & Misc Steel

package/skills/steel-takeoff/assets/bom-template.csv

@@ -1 +1 @@
-Mark,Qty,Size,Grade,Length_ft,Unit_Wt_plf,Total_Wt_lbs,Connections,Notes
+Source_ID,Mark,Qty,Size,Grade,Length_ft,Unit_Wt_plf,Total_Wt_lbs,Connections,Notes,Source_Sheet,Source_Detail,Intent

package/skills/steel-takeoff/references/takeoff-procedures.md

@@ -2,7 +2,9 @@
 
 ## Overview
 
-A steel takeoff quantifies every piece of structural steel on a project to determine total tonnage for bidding. Accuracy directly impacts profit margin — a 5% error on a 200-ton job is 10 tons ($32,000+ at current rates).
+A steel takeoff quantifies every piece of structural steel on a project to determine
+total tonnage for bidding. Accuracy directly affects quantities, schedule, and cost;
+this public guide intentionally contains no market rates or company pricing.
 
 ## Takeoff Order (recommended)
 

package/skills/steel-takeoff/scripts/calculate-weight.sh

@@ -4,13 +4,13 @@
 # Usage: ./scripts/calculate-weight.sh path/to/bom.csv [connection_pct] [misc_pct]
 #
 # BOM CSV format:
-#   Mark,Qty,Size,Grade,Length_ft,Unit_Wt_plf,Total_Wt_lbs,Connections,Notes
+#   Source_ID,Mark,Qty,Size,Grade,Length_ft,Unit_Wt_plf,...
 #
 # Optional arguments:
 #   connection_pct  - Connection allowance percentage (default: 12)
 #   misc_pct        - Misc steel allowance percentage (default: 5)
 #
-# Output: Line-by-line breakdown + totals with cost estimate
+# Output: Line-by-line breakdown + weight totals. Pricing is supplied separately.
 # ═══════════════════════════════════════════════════════════════════
 set -euo pipefail
 
@@ -68,7 +68,7 @@ with open(bom_file) as f:
 
         qty = int(row.get("Qty", 0))
         size = row.get("Size", "?").strip()
-        grade = row.get("Grade", "A992").strip()
+        grade = row.get("Grade", "").strip() or "UNSPECIFIED"
         length_str = row.get("Length_ft", "0").strip()
         unit_wt_str = row.get("Unit_Wt_plf", "0").strip()
 
@@ -136,13 +136,8 @@ print(f"  {'Misc Steel Allow ({:.0f}%):':<30} {misc_wt:>12,.0f} lb  ({misc_wt/20
 print(f"  {'─'*60}")
 print(f"  {'GRAND TOTAL:':<30} {grand_total:>12,.0f} lb  ({grand_total/2000:>8,.1f} tons)")
 print(f"  {'─'*60}")
-
-# Cost estimates at various $/ton rates
-print(f"\n  COST ESTIMATES:")
-tons = grand_total / 2000
-for rate in [2800, 3200, 3600, 4000]:
-    cost = tons * rate
-    print(f"    @ ${rate:,}/ton:  ${cost:>14,.0f}")
+print("\n  No price was calculated. Pricing requires an explicit currency, unit basis,")
+print("  effective date, and source supplied by the project input.")
 
 print(f"\n{'='*78}\n")
 PYTHON

package/skills/steel-takeoff/scripts/lookup-member.sh

@@ -1,13 +1,13 @@
 #!/usr/bin/env bash
 # ═══════════════════════════════════════════════════════════════════
-# AISC Member Lookup
+# StructuPath Member Lookup
 # Usage: ./scripts/lookup-member.sh "W14X30"
 #        ./scripts/lookup-member.sh "HSS8X6X1/2"
 #        ./scripts/lookup-member.sh "L4X4X3/8"
 #        ./scripts/lookup-member.sh "C10X20"
 #        ./scripts/lookup-member.sh "PIPE6STD"
 #
-# Searches the AISC shapes database and returns all properties.
+# Searches the bundled StructuPath shapes database and returns all properties.
 # Designation is case-insensitive, spaces are stripped.
 # ═══════════════════════════════════════════════════════════════════
 set -euo pipefail

package/skills/steel-takeoff/scripts/validate-bom.py

@@ -1,218 +1,173 @@
 #!/usr/bin/env python3
-"""
-BOM Validator — Validates a steel bill of materials CSV.
+"""Validate a legacy BOM through the canonical estimate-package contract."""
 
-Usage: python3 scripts/validate-bom.py path/to/bom.csv
+from __future__ import annotations
 
-Checks:
-  ✓ Valid AISC designations (cross-references shapes database)
-  ✓ Non-zero quantities and lengths
-  ✓ Correct grade for shape type
-  ✓ Reasonable weight-per-foot values
-  ✓ No duplicate marks
-  ✓ Required columns present
-"""
-
-import csv
+import argparse
 import json
-import os
 import sys
 from pathlib import Path
 
-def load_shapes_db():
-    """Load the AISC shapes database."""
-    skill_dir = Path(__file__).resolve().parent.parent
-    db_path = skill_dir / "assets" / "aisc-shapes-database.json"
-    if not db_path.exists():
-        print(f"WARNING: Shapes database not found at {db_path}")
-        return {}
 
-    with open(db_path) as f:
-        shapes = json.load(f)
+SHARED_ROOT = Path(__file__).resolve().parents[2] / "_shared"
+if str(SHARED_ROOT) not in sys.path:
+    sys.path.insert(0, str(SHARED_ROOT))
+from bootstrap import bootstrap_shared  # noqa: E402
 
-    return {s["designation"]: s for s in shapes}
+bootstrap_shared(__file__)
+from pi_steel.parsing import adapt_legacy_bom_csv  # noqa: E402
+from pi_steel.validation import validate_estimate_package  # noqa: E402
 
 
-def normalize_designation(raw: str) -> str:
-    """Normalize a steel designation for lookup."""
-    return raw.upper().replace(" ", "").strip()
+def load_shapes_db() -> dict[str, dict]:
+    db_path = Path(__file__).resolve().parent.parent / "assets" / "aisc-shapes-database.json"
+    if not db_path.exists():
+        return {}
+    shapes = json.loads(db_path.read_text(encoding="utf-8"))
+    return {shape["designation"]: shape for shape in shapes}
 
 
-def validate_grade(shape_type: str, grade: str) -> list[str]:
-    """Check if the material grade is appropriate for the shape type."""
-    warnings = []
-    grade_upper = grade.upper().strip()
+def normalize_designation(raw: str) -> str:
+    return raw.upper().replace(" ", "").strip()
 
-    # Standard grade assignments
-    standard_grades = {
-        "W":        ["A992", "A572", "A913", "A36"],
-        "HSS-RECT": ["A500", "A500 GR.C", "A500 GR. C", "A500GRC", "A500C"],
-        "HSS-RND":  ["A500", "A500 GR.B", "A500 GR. B", "A500GRB", "A500B", "A53"],
-        "C":        ["A36", "A572"],
-        "L":        ["A36", "A572"],
-        "PIPE":     ["A53", "A53 GR.B", "A53B", "A500"],
-    }
 
-    if shape_type in standard_grades:
-        valid = standard_grades[shape_type]
-        # Check if grade matches any valid option
-        matches = any(
-            grade_upper.replace(" ", "").replace(".", "").startswith(v.replace(" ", "").replace(".", ""))
-            for v in valid
+def grade_warnings(shape_type: str, grade: str) -> list[str]:
+    normalized = grade.upper().replace(" ", "").replace(".", "")
+    expected = {
+        "W": ("A992", "A572", "A913", "A36"),
+        "HSS-RECT": ("A500", "A500GRC"),
+        "HSS-RND": ("A500", "A500GRB", "A53"),
+        "C": ("A36", "A572"),
+        "L": ("A36", "A572"),
+        "PIPE": ("A53", "A500"),
+    }.get(shape_type, ())
+    if expected and not any(normalized.startswith(value) for value in expected):
+        return [f"Grade {grade!r} is unusual for shape type {shape_type}."]
+    return []
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    result.add_argument("bom", type=Path)
+    result.add_argument(
+        "--project-id",
+        default="SYNTHETIC-UNSPECIFIED",
+        help="Stable project identity used to derive canonical item IDs.",
+    )
+    result.add_argument(
+        "--revision-id",
+        default="SYNTHETIC-REV-UNSPECIFIED",
+        help="Source revision identity used to derive canonical item IDs.",
+    )
+    result.add_argument(
+        "--json",
+        action="store_true",
+        help="Print the validation result as JSON.",
+    )
+    return result
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    if not args.bom.is_file():
+        print(f"ERROR: File not found: {args.bom}", file=sys.stderr)
+        return 1
+    try:
+        package = adapt_legacy_bom_csv(
+            args.bom,
+            project_id=args.project_id,
+            revision_id=args.revision_id,
         )
-        if not matches:
-            warnings.append(
-                f"Grade '{grade}' unusual for {shape_type} — "
-                f"expected one of: {', '.join(standard_grades[shape_type][:3])}"
+    except (OSError, ValueError, TypeError) as exc:
+        print(f"ERROR: Could not parse BOM: {exc}", file=sys.stderr)
+        return 1
+
+    result = validate_estimate_package(package)
+    findings = list(result.active_findings)
+    shapes = load_shapes_db()
+    for index, item in enumerate(package["items"]):
+        designation = normalize_designation(item.get("designation", ""))
+        shape = shapes.get(designation)
+        if designation and shapes and shape is None and not designation.startswith(
+            ("PL", "PLATE", "BU", "WT")
+        ):
+            findings.append(
+                {
+                    "finding_id": f"legacy-shape:{index}",
+                    "code": "unverified_designation",
+                    "severity": "warning",
+                    "path": f"$.items[{index}].designation",
+                    "message": f"{item.get('designation')!r} was not found in the bundled reference data.",
+                    "relevant_hash": result.input_hash,
+                }
+            )
+        elif shape is not None:
+            unit_weight = item.get("unit_weight_plf")
+            if unit_weight and abs(unit_weight - shape["weight_per_ft"]) > 0.5:
+                findings.append(
+                    {
+                        "finding_id": f"legacy-weight:{index}",
+                        "code": "unit_weight_mismatch",
+                        "severity": "warning",
+                        "path": f"$.items[{index}].unit_weight_plf",
+                        "message": (
+                            f"Unit weight {unit_weight:g} plf does not match the "
+                            f"bundled reference value {shape['weight_per_ft']:g} plf."
+                        ),
+                        "relevant_hash": result.input_hash,
+                    }
+                )
+            for message in grade_warnings(shape["type"], item.get("grade", "")):
+                findings.append(
+                    {
+                        "finding_id": f"legacy-grade:{index}",
+                        "code": "unusual_grade",
+                        "severity": "warning",
+                        "path": f"$.items[{index}].grade",
+                        "message": message,
+                        "relevant_hash": result.input_hash,
+                    }
+                )
+        if item.get("length_ft", 0) > 80:
+            findings.append(
+                {
+                    "finding_id": f"legacy-length:{index}",
+                    "code": "unusual_member_length",
+                    "severity": "warning",
+                    "path": f"$.items[{index}].length_ft",
+                    "message": "Member length exceeds 80 ft; verify the source.",
+                    "relevant_hash": result.input_hash,
+                }
             )
 
-    return warnings
-
-
-def main():
-    if len(sys.argv) < 2:
-        print("Usage: python3 validate-bom.py <bom.csv>")
-        sys.exit(1)
-
-    bom_file = sys.argv[1]
-    if not os.path.exists(bom_file):
-        print(f"ERROR: File not found: {bom_file}")
-        sys.exit(1)
-
-    shapes_db = load_shapes_db()
-    errors = []
-    warnings = []
-    marks_seen = {}
-    total_weight = 0
-    line_num = 0
-
-    required_columns = {"Mark", "Qty", "Size", "Length_ft", "Unit_Wt_plf"}
-
-    print(f"\n{'='*60}")
-    print(f"  BOM VALIDATION: {os.path.basename(bom_file)}")
-    print(f"{'='*60}\n")
-
-    with open(bom_file) as f:
-        reader = csv.DictReader(f)
-
-        # Check required columns
-        if reader.fieldnames:
-            actual_cols = set(reader.fieldnames)
-            missing_cols = required_columns - actual_cols
-            if missing_cols:
-                errors.append(f"Missing required columns: {', '.join(missing_cols)}")
-
-        for row in reader:
-            line_num += 1
-            mark = row.get("Mark", "").strip()
-            if not mark or mark.startswith("#"):
-                continue
-
-            size = row.get("Size", "").strip()
-            grade = row.get("Grade", "").strip()
-            qty_str = row.get("Qty", "0").strip()
-            length_str = row.get("Length_ft", "0").strip()
-            unit_wt_str = row.get("Unit_Wt_plf", "0").strip()
-
-            prefix = f"Line {line_num} ({mark})"
-
-            # Check for duplicate marks
-            if mark in marks_seen:
-                warnings.append(f"{prefix}: Duplicate mark (also on line {marks_seen[mark]})")
-            marks_seen[mark] = line_num
-
-            # Validate quantity
-            try:
-                qty = int(qty_str) if qty_str else 0
-                if qty <= 0:
-                    errors.append(f"{prefix}: Quantity is {qty} — must be > 0")
-            except ValueError:
-                errors.append(f"{prefix}: Invalid quantity '{qty_str}'")
-                qty = 0
-
-            # Validate length
-            try:
-                if "'" in length_str:
-                    parts = length_str.replace('"', '').split("'")
-                    feet = float(parts[0].replace('-', '').strip())
-                    inches = float(parts[1].replace('-', '').strip()) if len(parts) > 1 and parts[1].strip() else 0
-                    length = feet + inches / 12.0
-                else:
-                    length = float(length_str) if length_str else 0
-                if length <= 0:
-                    errors.append(f"{prefix}: Length is {length} — must be > 0")
-                elif length > 80:
-                    warnings.append(f"{prefix}: Length {length:.1f} ft exceeds typical max (80 ft) — verify")
-            except ValueError:
-                errors.append(f"{prefix}: Invalid length '{length_str}'")
-                length = 0
-
-            # Validate unit weight
-            try:
-                unit_wt = float(unit_wt_str) if unit_wt_str else 0
-                if unit_wt <= 0:
-                    errors.append(f"{prefix}: Unit weight is {unit_wt} — must be > 0")
-            except ValueError:
-                errors.append(f"{prefix}: Invalid unit weight '{unit_wt_str}'")
-                unit_wt = 0
-
-            # Validate AISC designation
-            normalized = normalize_designation(size)
-            if shapes_db:
-                if normalized in shapes_db:
-                    db_shape = shapes_db[normalized]
-                    db_wt = db_shape["weight_per_ft"]
-                    if unit_wt > 0 and abs(unit_wt - db_wt) > 0.5:
-                        warnings.append(
-                            f"{prefix}: Unit weight {unit_wt} plf doesn't match "
-                            f"AISC database ({db_wt} plf) for {size}"
-                        )
-                    # Validate grade
-                    if grade:
-                        grade_warns = validate_grade(db_shape["type"], grade)
-                        warnings.extend(f"{prefix}: {w}" for w in grade_warns)
-                else:
-                    # Not a fatal error — could be a plate or built-up section
-                    if not any(normalized.startswith(p) for p in ["PL", "PLATE", "BU", "WT"]):
-                        warnings.append(f"{prefix}: '{size}' not found in AISC database — verify designation")
-
-            # Validate grade is present
-            if not grade:
-                warnings.append(f"{prefix}: No material grade specified")
-
-            total_weight += qty * length * unit_wt
-
-    # Print results
-    if errors:
-        print("  ❌ ERRORS (must fix):")
-        for e in errors:
-            print(f"     • {e}")
-        print()
-
-    if warnings:
-        print("  ⚠️  WARNINGS (review):")
-        for w in warnings:
-            print(f"     • {w}")
-        print()
-
-    print(f"  📊 SUMMARY:")
-    print(f"     Lines validated:  {line_num}")
-    print(f"     Unique marks:    {len(marks_seen)}")
-    print(f"     Errors:          {len(errors)}")
-    print(f"     Warnings:        {len(warnings)}")
-    print(f"     Total weight:    {total_weight:,.0f} lbs ({total_weight/2000:,.1f} tons)")
-
-    if errors:
-        print(f"\n  ❌ VALIDATION FAILED — {len(errors)} error(s) found")
-        print(f"{'='*60}\n")
-        sys.exit(1)
-    elif warnings:
-        print(f"\n  ⚠️  PASSED WITH WARNINGS — review {len(warnings)} warning(s)")
-        print(f"{'='*60}\n")
+    total_weight = sum(
+        item["quantity"] * item.get("length_ft", 0) * item.get("unit_weight_plf", 0)
+        for item in package["items"]
+        if item.get("intent") == "fabricated_part"
+    )
+    blockers = [finding for finding in findings if finding["severity"] == "blocker"]
+    warnings = [finding for finding in findings if finding["severity"] == "warning"]
+    output = {
+        "status": "invalid" if blockers else ("review_required" if warnings else "validated"),
+        "input_hash": result.input_hash,
+        "line_count": len(package["items"]),
+        "total_weight_lbs": total_weight,
+        "findings": findings,
+    }
+    if args.json:
+        print(json.dumps(output, indent=2, sort_keys=True))
     else:
-        print(f"\n  ✅ VALIDATION PASSED — no issues found")
-        print(f"{'='*60}\n")
+        print(f"BOM VALIDATION: {args.bom.name}")
+        for finding in findings:
+            label = "ERROR" if finding["severity"] == "blocker" else finding["severity"].upper()
+            print(f"{label}: {finding['path']}: {finding['message']}")
+        print(
+            f"SUMMARY: {len(package['items'])} lines; "
+            f"{total_weight:,.0f} lb; {len(blockers)} blockers; {len(warnings)} warnings"
+        )
+        print(f"STATUS: {output['status']}")
+    return 1 if blockers else 0
 
 
 if __name__ == "__main__":
-    main()
+    raise SystemExit(main())