@floless/app 0.59.1 → 0.61.0

package/dist/skills/floless-app-vectorize/scripts/extract_pdf.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Deterministic vector-PDF -> drawing.vector/v1 extractor (compose-time, no LLM).
+
+One PyMuPDF pass per page: every page.get_drawings() path becomes a geometry element
+(SVG `d` in DISPLAY coords) and every page.get_text("dict") span becomes a text element
+(baseline origin, real size, rotation). Emits a RAW drawing.vector/v1 contract ready to
+PUT to /api/contract/vectorize — the server's postProcess handles endpoint-snap, dedupe
+and layer derivation, but per-element ids are REQUIRED by the PUT schema, so this script
+assigns them (e1.. per sheet, s1.. sheets).
+
+Usage:
+
+  python extract_pdf.py drawing.pdf [more.pdf ...] [--out contract.json]
+
+The script forces UTF-8 on its own stdout/stderr (drawings contain glyphs like a diameter
+sign that crash Windows cp1250 consoles), so no shell-specific env setup is needed.
+
+Requires PyMuPDF (pip install pymupdf). A raster-only page (scan / photo / hand sketch)
+yields no geometry — that is the Slice-2 vision path, NOT this script's job; the caller
+must tell the user honestly instead of tracing pixels.
+"""
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import sys
+from datetime import datetime, timezone
+
+import fitz  # PyMuPDF
+
+
+def fmt(v):
+    """Compact numeric formatting for SVG path data."""
+    return f"{round(v, 2):g}"
+
+
+def rgb_hex(c):
+    """PyMuPDF float RGB tuple -> #rrggbb, or None."""
+    if c is None:
+        return None
+    r, g, b = (max(0, min(255, round(v * 255))) for v in c)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def int_hex(c):
+    """get_text span colour int (sRGB) -> #rrggbb."""
+    return f"#{(c or 0) & 0xFFFFFF:06x}"
+
+
+def path_to_element(pth, m):
+    """One get_drawings() path -> a geometry element dict (or None if it draws nothing).
+
+    Item -> SVG mapping: 'l' segments chain into M/L, 'c' cubic beziers into C,
+    're' rects and 'qu' quads into closed 4-corner polygons. Every point is mapped
+    through the page's rotation_matrix so a rotated page lands in display space.
+    """
+    d, pts, kinds = [], [], set()
+    cur = None
+    breaks = 0  # subpath breaks after the first M (disqualifies pts[])
+
+    def moveto(p):
+        nonlocal cur, breaks
+        if cur is not None:
+            breaks += 1
+        d.append(f"M{fmt(p.x)} {fmt(p.y)}")
+        pts.append([round(p.x, 2), round(p.y, 2)])
+        cur = p
+
+    def cont(p):
+        return cur is not None and abs(cur.x - p.x) < 1e-4 and abs(cur.y - p.y) < 1e-4
+
+    for item in pth["items"]:
+        op = item[0]
+        if op == "l":
+            p1, p2 = item[1] * m, item[2] * m
+            if abs(p1.x - p2.x) < 1e-6 and abs(p1.y - p2.y) < 1e-6:
+                continue  # zero-length
+            if not cont(p1):
+                moveto(p1)
+            d.append(f"L{fmt(p2.x)} {fmt(p2.y)}")
+            pts.append([round(p2.x, 2), round(p2.y, 2)])
+            cur = p2
+            kinds.add("l")
+        elif op == "c":
+            p1, c1, c2, p2 = (item[i] * m for i in (1, 2, 3, 4))
+            if not cont(p1):
+                moveto(p1)
+            d.append(f"C{fmt(c1.x)} {fmt(c1.y)} {fmt(c2.x)} {fmt(c2.y)} {fmt(p2.x)} {fmt(p2.y)}")
+            cur = p2
+            kinds.add("c")
+        elif op in ("re", "qu"):
+            q = item[1].quad if op == "re" else item[1]
+            ul, ur, lr, ll = (p * m for p in (q.ul, q.ur, q.lr, q.ll))
+            if cur is not None:
+                breaks += 1
+            d.append(
+                f"M{fmt(ul.x)} {fmt(ul.y)} L{fmt(ur.x)} {fmt(ur.y)} "
+                f"L{fmt(lr.x)} {fmt(lr.y)} L{fmt(ll.x)} {fmt(ll.y)} Z"
+            )
+            cur = None
+            kinds.add(op)
+
+    if not d:
+        return None
+    closed = bool(pth.get("closePath"))
+    if closed and not d[-1].endswith("Z"):
+        d.append("Z")
+
+    kind = "spline" if "c" in kinds else ("line" if kinds == {"l"} and len(pts) == 2 else "polyline")
+    el = {"kind": kind}
+    if kinds == {"l"} and breaks == 0 and len(pts) >= 2:
+        # Continuous straight-line chain: emit VERTICES ONLY (no `d`). Renderers rebuild the path
+        # from pts, and the server's endpoint-snap edits pts — a `d` alongside would shadow the
+        # snapped geometry (renderers prefer `d` when both are present).
+        if closed and pts[0] != pts[-1]:
+            pts.append(list(pts[0]))  # make the closing edge explicit — pts paths carry no Z
+        el["pts"] = pts
+        if len(pts) > 2:
+            el["kind"] = "polyline"
+    else:
+        el["d"] = " ".join(d)
+    color = rgb_hex(pth.get("color")) or rgb_hex(pth.get("fill"))
+    if color is None:
+        return None  # neither stroked nor filled -> draws nothing
+    el["color"] = color
+    if pth.get("width"):
+        el["w"] = round(pth["width"], 3)
+    dashes = (pth.get("dashes") or "").strip()
+    if dashes and dashes not in ("[] 0", "[]"):
+        el["dashed"] = True
+    if pth.get("layer"):
+        el["layer"] = pth["layer"]
+    return el
+
+
+def text_elements(page, m):
+    """get_text('dict') spans -> text elements with baseline origin, size, rotation, colour."""
+    rot = fitz.Matrix(m.a, m.b, m.c, m.d, 0, 0)  # rotation part only (for direction vectors)
+    out = []
+    for block in page.get_text("dict")["blocks"]:
+        if block.get("type") != 0:
+            continue
+        for line in block["lines"]:
+            dv = fitz.Point(line["dir"]) * rot
+            angle = round(math.degrees(math.atan2(dv.y, dv.x)), 2)
+            for span in line["spans"]:
+                if not span["text"].strip():
+                    continue
+                origin = fitz.Point(span["origin"]) * m
+                bbox = fitz.Rect(span["bbox"]) * m
+                bbox.normalize()
+                el = {
+                    "kind": "text",
+                    "text": span["text"],
+                    "origin": [round(origin.x, 2), round(origin.y, 2)],
+                    "bbox": [round(v, 2) for v in (bbox.x0, bbox.y0, bbox.x1, bbox.y1)],
+                    "size": round(span["size"], 2),
+                    "color": int_hex(span.get("color")),
+                }
+                if span.get("font"):
+                    el["font"] = span["font"]
+                if abs(angle) > 0.01:
+                    el["angle"] = angle
+                out.append(el)
+    return out
+
+
+def extract(paths):
+    sheets = []
+    for path in paths:
+        doc = fitz.open(path)
+        stem = os.path.splitext(os.path.basename(path))[0]
+        for pno in range(doc.page_count):
+            page = doc[pno]
+            m = page.rotation_matrix  # unrotated -> display space; page.rect is already display
+            elements = []
+            for pth in page.get_drawings():
+                el = path_to_element(pth, m)
+                if el:
+                    elements.append(el)
+            elements.extend(text_elements(page, m))
+            for i, el in enumerate(elements):
+                el["id"] = f"e{i + 1}"  # PUT schema requires ids; stable in document order
+            sheets.append({
+                "id": f"s{len(sheets) + 1}",
+                "label": f"{stem} p{pno + 1}",
+                "page": {"w": round(page.rect.width, 2), "h": round(page.rect.height, 2)},
+                "elements": elements,
+            })
+        doc.close()
+
+    first = paths[0]
+    name = os.path.basename(first) + (f" (+{len(paths) - 1} more)" if len(paths) > 1 else "")
+    return {
+        "type": "drawing.vector/v1",
+        "units": "pt",  # no transform emitted -> display space (PDF points) is world 1:1
+        "source": {
+            "name": name,
+            "path": os.path.abspath(first),
+            "kind": "pdf",
+            "sha256": hashlib.sha256(open(first, "rb").read()).hexdigest(),
+            "read_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            "extractor": f"pymupdf@compose-time ({getattr(fitz, 'VersionBind', '?')})",
+        },
+        "sheets": sheets,
+    }
+
+
+def main():
+    # Self-sufficient UTF-8 output regardless of console codepage (Windows cp1250 crashes on Ø/—).
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except AttributeError:
+            pass
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("pdfs", nargs="+", help="vector PDF file(s) to extract")
+    ap.add_argument("--out", help="write the contract JSON here instead of stdout")
+    args = ap.parse_args()
+
+    contract = extract(args.pdfs)
+    total = sum(len(s["elements"]) for s in contract["sheets"])
+    if total == 0:
+        print(
+            "WARNING: no vector geometry or text found — this looks like a raster-only PDF "
+            "(scan/photo). The deterministic path cannot read it; do not fabricate linework.",
+            file=sys.stderr,
+        )
+    if args.out:
+        with open(args.out, "w", encoding="utf-8") as f:
+            json.dump(contract, f, ensure_ascii=False)
+        print(f"{args.out}: {len(contract['sheets'])} sheet(s), {total} element(s)", file=sys.stderr)
+    else:
+        json.dump(contract, sys.stdout, ensure_ascii=False)
+
+
+if __name__ == "__main__":
+    main()

package/dist/skills/floless-app-vectorize/scripts/vision_to_contract.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""vision.extract result -> drawing.vector/v1 contract (the Slice-2 raster path).
+
+Takes the JSON that `aware agent invoke vision extract --json` printed (the invoke envelope
+or the bare `{result: {elements: [...]}}`) plus the image it was extracted from, and emits a
+raw drawing.vector/v1 contract ready to PUT to /api/contract/vectorize. The model traces in a
+normalized 0..1000 frame (see references/vision-inputs.template.json); this script maps that
+frame onto the image's real pixel size, carries each element's model-reported confidence
+(the 2D editor flags traces below 0.5 for review), and assigns the ids the PUT schema requires.
+
+Usage:
+
+  python vision_to_contract.py vision-out.json sketch.png --out contract.json
+  python vision_to_contract.py vision-out2.json page2.png --merge-into contract.json
+
+--merge-into appends the extraction as the next sheet of an existing contract (multi-image sets).
+Requires PyMuPDF (used only to read the image/PDF pixel size).
+"""
+
+import argparse
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+import fitz  # PyMuPDF
+
+
+def unwrap(payload):
+    """Accept the aware invoke envelope ({ok,data:{result,model}}) or the bare output."""
+    if payload.get("ok") is False:
+        sys.exit(f"vision.extract failed: {payload.get('error') or 'unknown error'}")
+    if isinstance(payload.get("data"), dict):
+        payload = payload["data"]
+    result = payload.get("result", payload)
+    model = payload.get("model", "?")
+    if not isinstance(result, dict) or "elements" not in result:
+        sys.exit("vision output has no result.elements — did the extraction fail?")
+    return result["elements"], model
+
+
+def to_sheet(elements, image_path):
+    # Images only: a multi-page PDF has no single 0..1000 frame, so the caller rasterizes each
+    # PDF page to its own image first (SKILL.md step 3b) and runs one extraction per image.
+    if image_path.lower().endswith(".pdf"):
+        sys.exit("pass the rasterized image, not the PDF — export each PDF page to a PNG first")
+    # True pixel dimensions (a Pixmap ignores DPI metadata, which would skew the frame).
+    pix = fitz.Pixmap(image_path)
+    w, h = float(pix.width), float(pix.height)
+    sx, sy = w / 1000.0, h / 1000.0
+
+    out = []
+    for el in elements:
+        kind = el.get("kind")
+        conf = el.get("confidence")
+        if kind == "text":
+            bbox = el.get("bbox")
+            if not el.get("text") or not bbox or len(bbox) != 4:
+                continue
+            x0, y0, x1, y1 = (v * s for v, s in zip(bbox, (sx, sy, sx, sy)))
+            e = {
+                "kind": "text",
+                "text": el["text"],
+                "bbox": [round(v, 1) for v in (x0, y0, x1, y1)],
+                "origin": [round(x0, 1), round(y1, 1)],  # baseline ~ bbox bottom-left
+                "size": round((y1 - y0) * 0.85, 1),      # approx font size from box height
+            }
+        elif kind in ("line", "polyline"):
+            pts = el.get("pts") or []
+            if len(pts) < 2:
+                continue
+            e = {
+                "kind": "line" if len(pts) == 2 else "polyline",
+                "pts": [[round(p[0] * sx, 1), round(p[1] * sy, 1)] for p in pts],
+            }
+            if el.get("dashed"):
+                e["dashed"] = True
+        else:
+            continue
+        # Schema: confidence is a number when present; ABSENT means trusted. A model that omits
+        # it must not become `null` — one null fails the whole PUT (server validates every write).
+        if isinstance(conf, (int, float)):
+            e["confidence"] = max(0.0, min(1.0, conf))
+        out.append(e)
+    for i, el in enumerate(out):
+        el["id"] = f"e{i + 1}"
+    return {"page": {"w": round(w, 2), "h": round(h, 2)}, "elements": out}
+
+
+def main():
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except AttributeError:
+            pass
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("vision_json", help="output of `aware agent invoke vision extract --json`")
+    ap.add_argument("image", help="the raster image the extraction ran on (rasterize PDF pages first)")
+    ap.add_argument("--out", help="write a NEW one-sheet contract here")
+    ap.add_argument("--merge-into", help="append as the next sheet of this existing contract")
+    args = ap.parse_args()
+    if bool(args.out) == bool(args.merge_into):
+        sys.exit("pass exactly one of --out / --merge-into")
+
+    with open(args.vision_json, encoding="utf-8") as f:
+        elements, model = unwrap(json.load(f))
+    sheet = to_sheet(elements, args.image)
+    stem = os.path.splitext(os.path.basename(args.image))[0]
+
+    if args.merge_into:
+        with open(args.merge_into, encoding="utf-8") as f:
+            contract = json.load(f)
+        if not isinstance(contract.get("sheets"), list):
+            sys.exit(f"{args.merge_into} is not a drawing.vector contract (no sheets[])")
+        used = {s.get("id") for s in contract["sheets"]}
+        n = len(contract["sheets"]) + 1
+        while f"s{n}" in used:
+            n += 1
+        sheet["id"] = f"s{n}"
+        sheet["label"] = stem
+        contract["sheets"].append(sheet)
+        path = args.merge_into
+    else:
+        sheet["id"] = "s1"
+        sheet["label"] = stem
+        with open(args.image, "rb") as f:
+            digest = hashlib.sha256(f.read()).hexdigest()
+        contract = {
+            "type": "drawing.vector/v1",
+            "units": "px",  # no transform emitted -> the image's pixel frame is world 1:1
+            "source": {
+                "name": os.path.basename(args.image),
+                "path": os.path.abspath(args.image),
+                "kind": "image",
+                "sha256": digest,
+                "read_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+                "extractor": f"vision.extract@{model}",
+            },
+            "sheets": [sheet],
+        }
+        path = args.out
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(contract, f, ensure_ascii=False)
+    weak = sum(1 for e in sheet["elements"] if (e.get("confidence") or 1) < 0.5)
+    print(f"{path}: sheet {sheet['id']} ({stem}), {len(sheet['elements'])} element(s), {weak} weak", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

package/dist/templates/vectorize.flo

@@ -0,0 +1,69 @@
+app:           vectorize
+version:       0.2.0
+display-name:  Vectorize
+publisher:     floless
+description: |
+  Turn any drawing — a sketch, a PDF, a photo — into clean, editable 2D vectors. Your terminal AI
+  reads the drawing ONCE at compose time and bakes it into a drawing.vector contract: a vector PDF
+  is read deterministically (exact geometry, no AI guessing), while a photo, scan or hand sketch is
+  traced by a fenced vision extraction that marks every stroke it was unsure about for your review.
+  Double-click the node to open the 2D vector editor, where you pan and zoom, toggle what's shown,
+  review weak traces, and export SVG. Attach a drawing and use "Re-read & re-bake ▸" (or ask your
+  terminal AI) to vectorize your own; the deterministic run just re-renders a short summary of what
+  was read. Ships with a tiny example so it works out of the box.
+exposes-as-agent: false
+# Workflow changelog (FloLess-published). Newest first; the app shows entries newer than the installed
+# version when offering an update. Plain-English — it surfaces to the user.
+changelog:
+  - version: 0.2.0
+    summary: Photos, scans and hand sketches can now be vectorized too — unsure strokes are flagged for your review
+  - version: 0.1.0
+    summary: Vectorize a drawing into clean 2D linework you can edit and export
+inputs:
+  drawing:
+    type: image
+    widget: file
+    accept: [pdf, png, jpg]
+    read-strategy: bake
+    description: A drawing to vectorize — read by your terminal AI into clean 2D vectors; swap to re-read & re-bake.
+requires:
+  - html-report@0.2.x
+layout: linear
+nodes:
+  # ── node 1: read — vectorize the drawing into clean 2D linework ───────────────
+  # This is where your drawing becomes editable vectors. Your terminal AI reads the
+  # attached drawing once at compose time: a vector PDF is read deterministically (exact
+  # geometry, no AI guessing), while a photo, scan or hand sketch is traced by a fenced
+  # vision extraction that flags every stroke it was unsure about. Every line, curve and
+  # label is baked into the contract. Double-click this node to open the 2D vector
+  # editor: pan and zoom the drawing, toggle Lines / Curves / Text, review each flagged
+  # trace (accept it as correct or delete it — edits save automatically), Export SVG,
+  # and Approve to freeze the reviewed drawing into the runnable lock. `contract` tells
+  # FloLess which editor to open; `takeoff` is the single source the editor, Approve and
+  # the run all read. It ships with a tiny EXAMPLE so it renders out of the box —
+  # "Re-read & re-bake ▸" replaces it with your own drawing. The deterministic run
+  # re-renders the short summary below.
+  - id: read
+    agent: html-report
+    command: render
+    config:
+      contract: drawing.vector/v1
+      takeoff:
+        type: drawing.vector/v1
+        units: mm
+        source: { name: "Example — sample detail (not your drawing)" }
+        sheets:
+          - id: s1
+            label: "Sample detail"
+            page: { w: 300, h: 200 }
+            elements:
+              - { id: e1, kind: polyline, d: "M60 50 H240 V150 H60 Z", color: "#334155", w: 1.4 }
+              - { id: e2, kind: line, d: "M150 30 L150 170", color: "#94a3b8", w: 0.8, dashed: true }
+              - { id: e3, kind: line, d: "M60 100 H240", color: "#94a3b8", w: 0.8 }
+              - { id: t1, kind: text, text: "SAMPLE DETAIL", size: 11, origin: [66, 44], color: "#334155" }
+              - { id: t2, kind: text, text: "PL 13mm", size: 9, origin: [98, 96], color: "#334155" }
+      title: "Vectorized drawing"
+      data:
+        - { Kind: Lines, Count: 3 }
+        - { Kind: Text, Count: 2 }
+connections: []

package/dist/web/aware.js

@@ -1360,14 +1360,18 @@
       // openContractEditor() returns false and the click would silently do nothing.
       if (contractType && window.CONTRACT_RENDERERS && window.CONTRACT_RENDERERS[contractType]) {
         addNodeAction(card, 'Edit contract ▸', () => openContractEditor(currentId, contractType));
-        addNodeAction(card, 'View 3D ▸', () => exportContract3d(currentId));
-        // Export/write group — visually separated from the look-and-read actions above.
-        addNodeActionDivider(card);
-        addNodeAction(card, 'Export IFC ▸', () => exportContractIfc(currentId));
-        addNodeAction(card, 'Export BOM (CSV) ▸', () => exportContractBom(currentId, 'csv'));
-        addNodeAction(card, 'Export BOM (Excel) ▸', () => exportContractBom(currentId, 'xlsx'));
-        const teklaBtn = addNodeAction(card, 'Send to Tekla ▸', () => exportContractTekla(currentId));
-        teklaBtn.dataset.tip = 'Tekla must be open with a model loaded. Click to create native parts in it.';
+        // The 3D/IFC/BOM/Tekla chain derives a scene from the contract — only contract types that
+        // declare `scene` support it (a drawing.vector node would 4xx on these endpoints).
+        if (window.CONTRACT_RENDERERS[contractType].scene) {
+          addNodeAction(card, 'View 3D ▸', () => exportContract3d(currentId));
+          // Export/write group — visually separated from the look-and-read actions above.
+          addNodeActionDivider(card);
+          addNodeAction(card, 'Export IFC ▸', () => exportContractIfc(currentId));
+          addNodeAction(card, 'Export BOM (CSV) ▸', () => exportContractBom(currentId, 'csv'));
+          addNodeAction(card, 'Export BOM (Excel) ▸', () => exportContractBom(currentId, 'xlsx'));
+          const teklaBtn = addNodeAction(card, 'Send to Tekla ▸', () => exportContractTekla(currentId));
+          teklaBtn.dataset.tip = 'Tekla must be open with a model loaded. Click to create native parts in it.';
+        }
         card.dataset.tip = 'Double-click to open the contract editor';
       }
       // Filter pre-stage node — opens the served steel-filter view (facets + eyedropper → contract.filter).
@@ -1752,9 +1756,9 @@
   function openContractEditor(appId, type) {
     const r = window.CONTRACT_RENDERERS && window.CONTRACT_RENDERERS[type];
     if (!r) return false;
-    // The editor bakes the .lock on Approve — that control belongs to the contract editor, not the
-    // filter view (which has its own Save). Make sure it's visible here (openFilterView hides it).
-    const ap0 = document.getElementById('contract-editor-approve'); if (ap0) ap0.hidden = false;
+    // The editor bakes the .lock on Approve — that control belongs to an editable contract editor, not
+    // the filter view (own Save) nor a view-only renderer. Show it unless the renderer is viewOnly.
+    const ap0 = document.getElementById('contract-editor-approve'); if (ap0) ap0.hidden = !!r.viewOnly;
     $contractEditorTitle.replaceChildren(
       Object.assign(document.createElement('span'), { textContent: appId, style: 'color:var(--text);font-weight:600' }),
       Object.assign(document.createElement('span'), { textContent: ' · ' + type, style: 'color:var(--text-muted)' }),

package/dist/web/renderers.js

@@ -9,9 +9,16 @@
  * ========================================================================== */
 
 // contract type → descriptor for the editor surface.
+// `scene: true` marks contracts that derive a 3D scene (contract-to-scene) — only those get the
+// node-card View 3D / Export IFC / Export BOM / Send to Tekla chain; other contract types would
+// 4xx or produce nonsense on those endpoints, so the shell hides the whole group.
 window.CONTRACT_RENDERERS = {
   'steel.takeoff/v1': {
     editorUrl: (appId) => '/steel-editor.html?app=' + encodeURIComponent(appId),
+    scene: true,
+  },
+  'drawing.vector/v1': {
+    editorUrl: (appId) => '/vector-editor.html?app=' + encodeURIComponent(appId),
   },
 };