@floless/app 0.60.0 → 0.62.0

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

@@ -1,18 +1,22 @@
 app:           vectorize
-version:       0.1.0
+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 (a deterministic PyMuPDF pass — no LLM) and bakes it into a
-  drawing.vector contract; double-click the node to open the 2D vector editor, where you pan and zoom,
-  toggle what's shown, flag 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.
+  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:
@@ -28,13 +32,17 @@ 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 (a deterministic PyMuPDF pass — no LLM) and bakes every line,
-  # curve and label into the contract. Double-click this node to open the 2D vector
-  # editor: pan and zoom the drawing, toggle Lines / Curves / Text, flag any weak traces,
-  # and Export SVG. `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.
+  # 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

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).

package/dist/web/renderers.js

@@ -9,15 +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),
-    // View-only for now: the vector editor renders + exports SVG but has no Save/edit path yet (the
-    // edit/re-bake flow is a later slice), so the shell hides its Approve button (see openContractEditor).
-    viewOnly: true,
   },
 };
 

package/dist/web/steel-3d-view.js

@@ -36,6 +36,7 @@ let soloGroups = new Set();                 // profile keys isolated via the leg
 let isolatedIds = null;                     // Tekla "isolate selected": Set of ids shown exclusively, or null for off
 let connHidden = new Set();                 // explicit per-PART hide (legend connection rows) — lets a shared part-kind (weld/nut) hide per-connection by id, not per group
 let cube = null;                            // ViewCube { renderer, scene, cam, mesh, faces }
+let triad = null;                           // world-axis triad { renderer, scene, cam, group } — passive X/Y/Z readout
 const DRAG_TOL_PX = 4;   // movement past this = a drag (not a click)
 const SNAP_TOL_PX = 10;  // snap an endpoint to a target within this screen distance
 const FT_MM = 304.8;     // mm per foot (the dimension readout shows feet, matching the editor)
@@ -150,6 +151,7 @@ function init(canvas, theApi) {
   window.addEventListener('keydown', onKey);           // Tekla keyboard nav: arrows pan, Ctrl/Shift+arrows rotate
   ro = new ResizeObserver(resize); ro.observe(canvas.parentElement || canvas);
   initCube();
+  initTriad();
   // Resize once more on the next frame: the stage may still be laying out when init() runs (the
   // designer flagged a first-render size mismatch as the common rough edge here).
   requestAnimationFrame(resize);
@@ -181,6 +183,7 @@ function loop() {
     renderer.autoClear = true; renderer.clippingPlanes = saved;
   }
   if (cube) { syncCube(); cube.renderer.render(cube.scene, cube.cam); }
+  if (triad) { syncTriad(); triad.renderer.render(triad.scene, triad.cam); }
 }
 
 const V = (x, y, z) => new THREE.Vector3(x, y, z);
@@ -1414,6 +1417,46 @@ function initCube() {
   });
   cube = { renderer: cr, scene: cs, cam: cc, mesh };
 }
+
+// ---- World-axis triad (Tekla-style) — a passive bottom-right gizmo showing where world X/Y/Z point.
+// Same sync-to-camera pattern as the ViewCube, but pointer-events:none: orientation CHANGES stay the
+// cube's job; this only reads out. Colors are the CAD convention (X red, Y green, Z blue = --brand).
+const TRIAD_AXES = [['X', '#ef4444', [1, 0, 0]], ['Y', '#22c55e', [0, 1, 0]], ['Z', '#3b82f6', [0, 0, 1]]];
+function triadTip(label, color, pos) {  // free-standing colored letter with a dark halo — legible over any geometry, no disc
+  const c = document.createElement('canvas'); c.width = c.height = 64; const g = c.getContext('2d');
+  g.font = 'bold 46px ui-sans-serif,system-ui,sans-serif'; g.textAlign = 'center'; g.textBaseline = 'middle';
+  g.lineWidth = 8; g.lineJoin = 'round'; g.strokeStyle = 'rgba(2,8,23,.9)'; g.strokeText(label, 32, 34);
+  g.fillStyle = color; g.fillText(label, 32, 34);
+  const s = new THREE.Sprite(new THREE.SpriteMaterial({ map: new THREE.CanvasTexture(c) }));
+  s.position.copy(pos); s.scale.setScalar(0.85);
+  return s;
+}
+function initTriad() {
+  const host = document.getElementById('m3dAxes'); if (!host) return;
+  const PX = 78;
+  const tr = new THREE.WebGLRenderer({ antialias: true, alpha: true });
+  tr.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2)); tr.setSize(PX, PX);
+  host.appendChild(tr.domElement);
+  const ts = new THREE.Scene();
+  const tc = new THREE.OrthographicCamera(-2.1, 2.1, 2.1, -2.1, 0.1, 20); tc.position.set(0, 0, 5);
+  const g = new THREE.Group();
+  const Y = new THREE.Vector3(0, 1, 0);   // Cylinder/ConeGeometry's own axis
+  for (const [label, color, dir] of TRIAD_AXES) {
+    const d = new THREE.Vector3(dir[0], dir[1], dir[2]);
+    const mat = new THREE.MeshBasicMaterial({ color });
+    const shaft = new THREE.Mesh(new THREE.CylinderGeometry(0.06, 0.06, 1.05, 8), mat);
+    shaft.quaternion.setFromUnitVectors(Y, d);
+    shaft.position.copy(d).multiplyScalar(0.525);
+    const head = new THREE.Mesh(new THREE.ConeGeometry(0.16, 0.34, 12), mat);   // arrowhead at the shaft end
+    head.quaternion.copy(shaft.quaternion);
+    head.position.copy(d).multiplyScalar(1.22);
+    g.add(shaft, head, triadTip(label, color, d.clone().multiplyScalar(1.62)));
+  }
+  g.add(new THREE.Mesh(new THREE.SphereGeometry(0.1, 12, 8), new THREE.MeshBasicMaterial({ color: 0xe2e8f0 })));  // origin dot
+  ts.add(g);
+  triad = { renderer: tr, scene: ts, cam: tc, group: g };
+}
+function syncTriad() { triad.group.quaternion.copy(camera.quaternion).invert(); }
 // Mirror the scene from the main camera's direction (the FRONT face turns toward the viewer in a
 // front view, etc.) by orienting the cube by the inverse of the camera's world rotation.
 function syncCube() { cube.mesh.quaternion.copy(camera.quaternion).invert(); }
@@ -1826,10 +1869,12 @@ function dispose() {
   window.removeEventListener('keydown', onKey);
   for (const ovl of [readout, hoverChip, rubber, dimLabelHost]) if (ovl && ovl.parentNode) ovl.parentNode.removeChild(ovl);
   dimLabelHost = null; dimLabelPool.length = 0;
-  if (cube) {
-    cube.scene.traverse((o) => { if (o.geometry) o.geometry.dispose(); const mm = Array.isArray(o.material) ? o.material : (o.material ? [o.material] : []); for (const m of mm) { if (m.map) m.map.dispose(); m.dispose(); } });
-    cube.renderer.dispose(); if (cube.renderer.domElement.parentNode) cube.renderer.domElement.parentNode.removeChild(cube.renderer.domElement); cube = null;
+  for (const w of [cube, triad]) {   // both mini-widgets own a WebGL context — leak one and re-init eventually hits the browser's context cap
+    if (!w) continue;
+    w.scene.traverse((o) => { if (o.geometry) o.geometry.dispose(); const mm = Array.isArray(o.material) ? o.material : (o.material ? [o.material] : []); for (const m of mm) { if (m.map) m.map.dispose(); m.dispose(); } });
+    w.renderer.dispose(); if (w.renderer.domElement.parentNode) w.renderer.domElement.parentNode.removeChild(w.renderer.domElement);
   }
+  cube = triad = null;
   if (epGeom) epGeom.dispose(); if (epMatStart) epMatStart.dispose(); if (epMatEnd) epMatEnd.dispose();
   if (dims3dGroup) { if (scene) scene.remove(dims3dGroup); for (const c of dims3dGroup.children) { c.geometry.dispose(); c.material.dispose(); } } // placed-dim lines
   if (overlayDimsGroup) { if (scene) scene.remove(overlayDimsGroup); for (const c of overlayDimsGroup.children) { c.geometry.dispose(); c.material.dispose(); } } // derived dim-overlay lines