Skip to content

K-Dense-AI/scientific-agent-skills / skills/fictiv

fictiv

Verified

Operates Fictiv (app.fictiv.com), the on-demand manufacturing platform, end to end in the user's browser. Covers uploading CAD parts, configuring process, material, finish, threads, tolerances and inspections, getting instant or manual quotes, reading and fixing DFM feedback, choosing lead time and region, checking out and paying (card or PO), tracking orders, reordering, and troubleshooting. Applies when the user mentions Fictiv, wants a part CNC machined, 3D printed, sheet-metal fabricated, urethane cast, injection or compression molded, or die cast through an online service, asks to "get a quote" or "order parts" for a STEP/SLDPRT/STL file, wants to check a Fictiv quote or order status, or has a problem with a Fictiv upload, DFM warning, price or checkout. Also applies when the user wants custom parts manufactured and has a Fictiv account, even if Fictiv is not named.

scripts/check_cad_file.py

View on GitHub
#!/usr/bin/env python3
"""Pre-flight check for CAD files before uploading them to Fictiv.

Catches the problems that most often make a Fictiv upload fail, go to manual
review, or come back mis-scaled — before you spend a browser round-trip on it.

Usage:
    python3 check_cad_file.py PART.step [MORE FILES...] [--process cnc|3dp|sheet|urethane|im|compression|diecast] [--json]

Checks performed (standard library only, no CAD kernel needed):
  * documented format support for the chosen process (mesh = 3D printing only;
    uploader acceptance alone is not manufacturing support)
  * STEP: schema, declared length unit, number of solid bodies (Fictiv needs
    one in most cases), surface-only models, assemblies, approximate bounding box
  * STL: ascii/binary, triangle count, watertightness (every edge shared by
    exactly two triangles), bounding box, and a units sanity guess
  * PDF: reminds you a drawing must accompany a CAD file
  * rough size vs. Fictiv's published max build envelopes

This is a heuristic pre-flight, not CAD-kernel validation or export classification.
Native files and PDF contents are not inspected. An OK result does not certify
manufacturability, topology, units, or absence of export-controlled data.
Exit code: 0 = no blocking problems detected, 1 = at least one blocking problem.
"""
from __future__ import annotations

import argparse
import json
import os
import re
import struct
import sys
from collections import Counter

# Manufacturing formats documented in the Help Center, reviewed 2026-09-30:
# https://www.fictiv.com/help/uploading-and-organizing-parts/what-file-formats-does-fictiv-support
# The upload widget's accept list also contains unsupported/reference-only types.
PARAMETRIC = {
    ".3dm", ".3dxml", ".cgr", ".catpart", ".catshape", ".dlv", ".exp", ".ifc",
    ".ipt", ".jt", ".mf1", ".model", ".neu", ".par", ".prc", ".prt", ".sab",
    ".sat", ".session", ".sldprt", ".step", ".stp", ".u3d", ".vda", ".x3dv",
    ".x_b", ".x_t", ".xas", ".xpr",
}
UPLOAD_ONLY = {".3mf", ".arc", ".gts", ".ifczip", ".pkg", ".unv", ".xmt", ".xmt_txt"}
# Mesh formats: 3D printing only.
MESH = {".stl", ".3ds", ".collada", ".dae", ".obj", ".off", ".ply", ".v3d", ".pts",
        ".tri", ".acs", ".x3d", ".wrl"}
ASSEMBLY = {".sldasm", ".asm", ".iam", ".catproduct"}
UNSUPPORTED = {".igs": "IGES", ".iges": "IGES", ".f3d": "Fusion 360 archive",
               ".slddrw": "SolidWorks drawing", ".dxf": "DXF", ".dwg": "DWG",
               ".catdrawing": "CATIA drawing", ".psm": "Solid Edge sheet metal",
               ".pwd": "Solid Edge weldment"}

# Published max envelopes in mm (largest first); used only for a soft warning.
MAX_ENVELOPE_MM = {
    "cnc": (1828, 500, 152),        # mill, per Help Center; larger parts via sales
    "3dp": (914, 609, 914),         # largest FDM; other technologies are smaller
    "urethane": (2200, 1200, 1000),
}
PROCESSES = ["cnc", "3dp", "sheet", "urethane", "im", "compression", "diecast"]


def human(n: float) -> str:
    return f"{n / 1e6:.1f} MB" if n >= 1e6 else f"{n / 1e3:.0f} KB"


# ---------------------------------------------------------------- STEP ----
def inspect_step(path: str) -> dict:
    info: dict = {}
    with open(path, "r", errors="ignore") as fh:
        data = fh.read()
    head = data[:5000]
    m = re.search(r"FILE_SCHEMA\s*\(\s*\(\s*'([^']+)'", head)
    info["schema"] = m.group(1) if m else None
    ents = Counter(re.findall(r"#\d+\s*=\s*([A-Z_0-9]+)\s*\(", data))
    solids = ents["MANIFOLD_SOLID_BREP"] + ents["BREP_WITH_VOIDS"]
    info["solid_bodies"] = solids
    info["surface_models"] = ents["SHELL_BASED_SURFACE_MODEL"] + ents["OPEN_SHELL"]
    info["products"] = ents["PRODUCT"]
    info["assembly_links"] = ents["NEXT_ASSEMBLY_USAGE_OCCURRENCE"]

    # Units: look for CONVERSION_BASED_UNIT('INCH'...) or SI_UNIT(.MILLI.,.METRE.)
    if re.search(r"CONVERSION_BASED_UNIT\s*\(\s*'(INCH|IN)'", data, re.I):
        info["length_unit"] = "inch"
    elif re.search(r"SI_UNIT\s*\(\s*\.MILLI\.\s*,\s*\.METRE\.", data):
        info["length_unit"] = "mm"
    elif re.search(r"SI_UNIT\s*\(\s*\.CENTI\.\s*,\s*\.METRE\.", data):
        info["length_unit"] = "cm"
    elif re.search(r"SI_UNIT\s*\(\s*\$\s*,\s*\.METRE\.", data):
        info["length_unit"] = "m"
    else:
        info["length_unit"] = "unknown"

    # Approximate bounding box from the B-rep's vertex points. Axis placements
    # and surface origins are also CARTESIAN_POINTs and can sit outside the
    # solid, so only fall back to "all points" when there are no vertices.
    # Parts bounded purely by curved faces (e.g. a sphere) can read small.
    allpts = dict(re.findall(r"#(\d+)\s*=\s*CARTESIAN_POINT\s*\(\s*'[^']*'\s*,\s*\(\s*([-\d.E+]+\s*,\s*[-\d.E+]+\s*,\s*[-\d.E+]+)\s*\)", data))
    vids = re.findall(r"VERTEX_POINT\s*\(\s*'[^']*'\s*,\s*#(\d+)\s*\)", data)
    chosen = [allpts[i] for i in vids if i in allpts] or list(allpts.values())
    pts = [tuple(s.strip() for s in p.split(",")) for p in chosen]
    if pts:
        xs, ys, zs = zip(*((float(a), float(b), float(c)) for a, b, c in pts))
        scale = {"inch": 25.4, "mm": 1.0, "cm": 10.0, "m": 1000.0}.get(info["length_unit"])
        dims = sorted((max(v) - min(v) for v in (xs, ys, zs)), reverse=True)
        if scale is None:
            info["approx_bbox_units"] = [round(d, 2) for d in dims]
        else:
            info["approx_bbox_mm"] = [round(d * scale, 2) for d in dims]
    if re.search(r"\bITAR\b|ITAR[- ]CONTROLLED|22 CFR 120", data, re.I):
        info["itar_marking"] = True
    return info


# ----------------------------------------------------------------- STL ----
def inspect_stl(path: str, max_tris: int = 3_000_000) -> dict:
    info: dict = {}
    size = os.path.getsize(path)
    with open(path, "rb") as fh:
        header = fh.read(84)
        is_binary = False
        if len(header) == 84:
            n = struct.unpack("<I", header[80:84])[0]
            is_binary = 84 + n * 50 == size
        tris = []
        if is_binary:
            info["encoding"] = "binary"
            info["triangles"] = n
            if n <= max_tris:
                for _ in range(n):
                    rec = fh.read(50)
                    v = struct.unpack("<12f", rec[:48])
                    tris.append((v[3:6], v[6:9], v[9:12]))
        else:
            info["encoding"] = "ascii"
            fh.seek(0)
            verts = re.findall(rb"vertex\s+([-\d.eE+]+)\s+([-\d.eE+]+)\s+([-\d.eE+]+)", fh.read())
            vv = [tuple(float(c) for c in v) for v in verts]
            tris = [tuple(vv[i:i + 3]) for i in range(0, len(vv) - 2, 3)]
            info["triangles"] = len(tris)
    if tris:
        xs = [p[0] for t in tris for p in t]
        ys = [p[1] for t in tris for p in t]
        zs = [p[2] for t in tris for p in t]
        info["bbox_units"] = sorted([round(max(a) - min(a), 3) for a in (xs, ys, zs)], reverse=True)
        edges: Counter = Counter()
        for t in tris:
            k = [tuple(round(c, 5) for c in p) for p in t]
            for a, b in ((k[0], k[1]), (k[1], k[2]), (k[2], k[0])):
                edges[(a, b) if a < b else (b, a)] += 1
        bad = sum(1 for c in edges.values() if c != 2)
        info["non_manifold_or_open_edges"] = bad
        info["watertight"] = bad == 0
    elif info.get("triangles", 0) > max_tris:
        info["note"] = "too many triangles to check watertightness quickly"
    return info


# -------------------------------------------------------------- driver ----
def check(path: str, process: str) -> dict:
    ext = os.path.splitext(path)[1].lower()
    r = {"file": path, "extension": ext, "process": process, "blocking": [], "warnings": [], "info": {}}
    if not os.path.isfile(path):
        r["blocking"].append("file not found")
        return r
    size = os.path.getsize(path)
    r["info"]["size"] = human(size)
    if size == 0:
        r["blocking"].append("file is empty")
    if size > 100e6:
        r["warnings"].append("very large file (>100 MB); Fictiv documents no limit but uploads may time out — "
                             "try STEP or a lighter mesh")

    if ext in UNSUPPORTED:
        r["blocking"].append(f"{UNSUPPORTED[ext]} ({ext}) is not accepted by Fictiv — export STEP (.step) "
                             "or a native part file instead")
    elif ext in ASSEMBLY:
        r["blocking"].append("assembly files are only accepted as BOM reference and cannot be quoted — "
                             "export each part as its own single-body STEP")
    elif ext == ".pdf":
        r["warnings"].append("PDF drawings cannot be quoted alone; attach it to its CAD part "
                             "(Configure > Technical drawing > Upload drawing) or upload it together with the CAD file")
    elif ext in MESH:
        if process != "3dp":
            r["blocking"].append(f"mesh files ({ext}) are accepted for 3D printing only; "
                                 f"{process} needs STEP or native CAD")
    elif ext in UPLOAD_ONLY:
        r["blocking"].append(f"{ext} appeared in the uploader but manufacturing support is unverified; "
                             "export STEP or a documented format before submitting")
    elif ext not in PARAMETRIC:
        r["blocking"].append(f"unrecognized extension {ext}; not in the verified Fictiv format list")

    if ext == ".prt":
        r["warnings"].append(".prt is ambiguous (Siemens NX vs PTC Creo); if upload fails, export STEP")
    if ext == ".sldprt":
        r["warnings"].append("SolidWorks files with multiple configurations are rejected — save a single configuration")

    if ext in (".step", ".stp"):
        s = inspect_step(path)
        r["info"].update(s)
        if s["solid_bodies"] == 0 and s["surface_models"]:
            r["blocking"].append("STEP contains only surface geometry (no closed solid) — Fictiv needs a solid body")
        elif s["solid_bodies"] == 0:
            r["blocking"].append("no solid body found in STEP")
        elif s["solid_bodies"] > 1:
            msg = (f"{s['solid_bodies']} solid bodies in one file — split separate parts into separate files. "
                   "CNC modeled-in pins/inserts and functional 3DP interlinked bodies have exceptions; "
                   "this checker cannot determine eligibility. Separate floating 3DP bodies are not accepted")
            (r["warnings"] if process == "3dp" else r["blocking"]).append(msg)
        if s["assembly_links"]:
            r["warnings"].append("STEP is structured as an assembly; export the single part instead")
        if s["length_unit"] == "unknown":
            r["warnings"].append("could not determine STEP length unit; check the size Fictiv shows after upload")
        if s.get("itar_marking"):
            r["blocking"].append("file text contains ITAR markings — Fictiv does not accept ITAR data; do not upload")
    elif ext == ".stl":
        s = inspect_stl(path)
        r["info"].update(s)
        if s.get("watertight") is False:
            r["warnings"].append(f"mesh is not watertight ({s['non_manifold_or_open_edges']} open/non-manifold edges) — "
                                 "repair it (e.g. Netfabb, Meshmixer) or re-export from the solid modeler")
        bb = s.get("bbox_units")
        if bb:
            if bb[0] < 5:
                r["warnings"].append(f"largest dimension is {bb[0]} units — if the part is really in inches, choose "
                                     "inches at upload or it will be 25.4x too small")
            if bb[0] > 1500:
                r["warnings"].append(f"largest dimension is {bb[0]} units — check units (metres/mm mix-up?)")
            r["info"]["bbox_if_mm"] = bb
            r["info"]["bbox_if_inch_in_mm"] = [round(v * 25.4, 2) for v in bb]

    bbox = r["info"].get("approx_bbox_mm")
    env = MAX_ENVELOPE_MM.get(process)
    # bbox is sorted largest-first, so compare against the envelope sorted the
    # same way: the part may be oriented to fit, whatever the machine axes are.
    if bbox and env and any(b > e for b, e in zip(bbox, sorted(env, reverse=True))):
        r["warnings"].append(f"approx size {bbox} mm exceeds Fictiv's published {process} envelope {list(env)} mm — "
                             "expect manual review/sales involvement, or split the part")
    return r


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("files", nargs="+")
    ap.add_argument("--process", choices=PROCESSES, default="cnc")
    ap.add_argument("--json", action="store_true", help="print machine-readable JSON")
    a = ap.parse_args()
    results = [check(f, a.process) for f in a.files]
    if a.json:
        print(json.dumps(results, indent=2))
    else:
        for r in results:
            status = "BLOCKED" if r["blocking"] else ("WARN" if r["warnings"] else "OK")
            print(f"[{status}] {r['file']}  ({a.process})")
            for k, v in r["info"].items():
                print(f"    {k}: {v}")
            for b in r["blocking"]:
                print(f"    [FAIL] {b}")
            for w in r["warnings"]:
                print(f"    ! {w}")
    return 1 if any(r["blocking"] for r in results) else 0


if __name__ == "__main__":
    sys.exit(main())
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall