opentakeoff-mcp 0.8.0 → 0.9.0

package/README.md

@@ -1,7 +1,8 @@
 # OpenTakeoff MCP server
 
 Listed in the [official MCP registry](https://registry.modelcontextprotocol.io) as
-`io.github.Kentucky-ai/opentakeoff` and on [Glama](https://glama.ai/mcp/servers/Kentucky-ai/opentakeoff).
+`io.github.Kentucky-ai/opentakeoff`, on [Glama](https://glama.ai/mcp/servers/Kentucky-ai/opentakeoff),
+and on [Smithery](https://smithery.ai/servers/Kentucky-ai/opentakeoff).
 
 ## Run it in 60 seconds (npx)
 
@@ -240,23 +241,48 @@ npm test        # session + tool-layer + e2e, against demo/sample-plan.pdf
 MCP releases live in the **`mcp-v*`** tag namespace — bare `v*` tags belong to
 the app (v0.2.0, v0.3.0 are app releases). Releases publish via **npm trusted
 publishing**: the tag push fires `.github/workflows/publish-mcp.yml`, which
-pauses at the `release` environment for maintainer approval, then publishes
-the npm artifact over OIDC with a **provenance attestation** (no npm token
-exists anywhere — the npm package designates that exact repo + workflow as
-its trusted publisher), followed by the MCP registry entry, the GitHub
-release, and the MCPB bundle.
+runs straight through — no approval click — and publishes the npm artifact
+over OIDC with a **provenance attestation** (no npm token exists anywhere —
+the npm package designates that exact repo + workflow as its trusted
+publisher), followed by the MCP registry entry, the GitHub release, and the
+MCPB bundle. The `release` environment's required-reviewer gate existed
+briefly and was deliberately removed (2026-07-22) — the tag push is the one
+human decision, and it's already admin-gated, so a second click added
+friction without adding safety.
 
 ```bash
 # 1. bump the version — all three fields together:
 #    package.json .version, server.json .version, server.json .packages[0].version
-# 2. tag and push — this fires the whole release:
+# 2. tag and push — this fires the whole release, fully unattended:
 git tag mcp-v<version> && git push origin mcp-v<version>
-# 3. approve the run (GitHub → Actions → the paused "Publish to MCP Registry" run)
 ```
 
+⚠️ Because there's no approval step, an accidental or mistyped `mcp-v*` tag
+publishes to npm immediately, and npm unpublish is heavily restricted —
+double-check the version before tagging.
+
 The workflow checks version consistency, runs the full publish gate
 (`prepublishOnly` = typecheck + tests + build), publishes to npm and the
 official MCP registry, verifies the registry listing, and creates the GitHub
 release (titled `opentakeoff-mcp <version>`). A re-run skips the npm publish
 if that version already shipped, so a transient failure downstream is safe to
 retry.
+
+### Refreshing the Smithery listing
+
+Smithery isn't part of the automated release above — it needs a **separate,
+manual** publish after any tool signature change, because of a genuine spec
+conflict between two validators: the official MCPB validator (what
+`npm run mcpb` gates on) rejects a `tools[].inputSchema` key outright, while
+Smithery's registry rejects a bundle *without* real `inputSchema` per tool
+(smithery-ai/cli#770, #797, #787 — no manifest satisfies both). The canonical
+`dist-mcpb/opentakeoff-mcp.mcpb` stays spec-compliant for Claude Desktop / the
+official registry / Glama; `scripts/build-smithery-mcpb.mjs` builds a
+Smithery-only bundle instead, with live-introspected tools + inputSchema baked
+in, packed with a plain zip (bypassing `mcpb validate`, which would reject it):
+
+```bash
+npm run build
+node scripts/build-smithery-mcpb.mjs
+smithery mcp publish dist-smithery/opentakeoff-mcp.mcpb -n Kentucky-ai/opentakeoff
+```

package/dist/server-core.js

@@ -1073,7 +1073,7 @@ function drawShapes(ctx, toCanvas, shapes, sheetW, sheetH, longEdge) {
 var SNAP_CELL = 24;
 var SNAP_TOL = 7;
 var PALETTE = ["#c96442", "#2f7d54", "#2563eb", "#9333ea", "#b8860b", "#0d9488", "#be185d", "#1f2937", "#dc2626", "#0891b2"];
-var HATCH_IDS = ["solid", "diag", "diag2", "cross", "diagdense", "horiz", "vert", "grid", "brick", "plank", "herring", "basket", "checker", "wave", "fleur", "speckle"];
+var HATCH_IDS = ["solid", "diag", "diag2", "cross", "diagdense", "horiz", "vert", "grid", "brick", "plank", "herring", "basket", "checker", "wave", "dots", "speckle", "iso", "honeycomb", "scan", "plus", "circuit", "topo"];
 var mintUuid = () => globalThis.crypto && typeof globalThis.crypto.randomUUID === "function" ? globalThis.crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 var uid = (p) => `${p}-${mintUuid()}`;
 var ANN_SCHEMA = "opentakeoff.takeoff_canvas.v1";
@@ -1121,6 +1121,7 @@ var Session = class {
   doc = null;
   sheets = /* @__PURE__ */ new Map();
   conditions = [];
+  markups = [];
   shapes = [];
   /** Newest-last. Capped at UNDO_CAP; the oldest entry falls off the front. */
   journal = [];
@@ -1148,6 +1149,7 @@ var Session = class {
     this.sheets.clear();
     this.conditions = [];
     this.shapes = [];
+    this.markups = [];
     this.file = null;
     this.journal = [];
     this.pendingCommits = [];
@@ -1805,6 +1807,95 @@ var Session = class {
       ...undone.length < n ? { note: `Only ${undone.length} step(s) were available to undo.` } : {}
     };
   }
+  /** Place an annotation. A note ABOUT the work — it never measures anything
+   *  and never touches a quantity, which is why there is no review gate here:
+   *  the pencil-not-ink rule exists to stop an agent inventing GEOMETRY, and a
+   *  cloud saying "verify substrate" is not geometry.
+   *
+   *  `condition` attaches it to a scope by finish tag, minting the condition on
+   *  first touch exactly like one_click/measure_polygon — so an agent can note
+   *  something about CPT-1 before anything is traced for CPT-1. Omit it for a
+   *  note about the sheet rather than about a finish. */
+  annotate(a) {
+    const s = this.sheet(a.sheet);
+    const n = ([x, y]) => [x / s.widthPx, y / s.heightPx];
+    if ((a.type === "cloud" || a.type === "highlight") && !a.rect) throw new UserError(`a ${a.type} needs rect: [[x0,y0],[x1,y1]] in image px`);
+    if ((a.type === "text" || a.type === "callout") && !a.at) throw new UserError(`a ${a.type} needs at: [x,y] in image px`);
+    if (a.type === "callout" && !a.target) throw new UserError("a callout needs target: [x,y] \u2014 the point the leader line aims at");
+    const cond = a.condition ? this.conditionFor(a.condition) : null;
+    const m = {
+      id: uid("mk"),
+      sheet_id: s.key,
+      type: a.type,
+      text: a.text || "",
+      condition_id: cond?.id ?? "",
+      rfi_id: "",
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...a.at ? { at: n(a.at) } : {},
+      ...a.target ? { target: n(a.target) } : {},
+      ...a.rect ? { rect: [n(a.rect[0]), n(a.rect[1])] } : {}
+    };
+    this.markups.push(m);
+    return {
+      id: m.id,
+      sheet: s.key,
+      type: m.type,
+      text: m.text,
+      condition: cond?.finish_tag ?? "",
+      condition_id: m.condition_id,
+      note: cond ? `Attached to ${cond.finish_tag} \u2014 it wears that condition's colour on the canvas and in the marked set.` : "Unattached \u2014 a note about the sheet. Pass condition to tie it to a scope."
+    };
+  }
+  /** Read annotations, optionally narrowed to a sheet and/or a condition.
+   *  Resolves condition_id to its finish tag so a caller can act on the reply
+   *  without joining against the conditions array. */
+  listAnnotations(f = {}) {
+    const tagById = new Map(this.conditions.map((c) => [c.id, c.finish_tag]));
+    let rows = this.markups;
+    if (f.sheet) {
+      const s = this.sheet(f.sheet);
+      rows = rows.filter((m) => m.sheet_id === s.key);
+    }
+    if (f.condition) {
+      const c = this.conditions.find((x) => x.finish_tag === f.condition);
+      if (!c) throw new UserError(`no condition "${f.condition}" \u2014 tags: ${this.conditions.map((x) => x.finish_tag).join(", ") || "(none)"}`);
+      rows = rows.filter((m) => m.condition_id === c.id);
+    }
+    const s0 = this.sheets;
+    const px = (m, p) => {
+      const sh = s0.get(m.sheet_id);
+      if (!p || !sh) return void 0;
+      return [round1(p[0] * sh.widthPx), round1(p[1] * sh.heightPx)];
+    };
+    return {
+      annotations: rows.map((m) => ({
+        id: m.id,
+        sheet: m.sheet_id,
+        type: m.type,
+        text: m.text,
+        condition: tagById.get(m.condition_id) ?? "",
+        condition_id: m.condition_id,
+        ...m.at ? { at: px(m, m.at) } : {},
+        ...m.target ? { target: px(m, m.target) } : {},
+        ...m.rect ? { rect: [px(m, m.rect[0]), px(m, m.rect[1])] } : {}
+      })),
+      count: rows.length,
+      unattached: rows.filter((m) => !m.condition_id).length
+    };
+  }
+  /** Attach an existing annotation to a condition, or detach it with "". The
+   *  canvas's Attach/Detach, reachable by an agent. */
+  linkAnnotation(id, condition) {
+    const m = this.markups.find((x) => x.id === id);
+    if (!m) throw new UserError(`no annotation "${id}" \u2014 call list_annotations for real ids`);
+    if (!condition) {
+      m.condition_id = "";
+      return { id: m.id, condition: "", note: "Detached \u2014 now a note about the sheet." };
+    }
+    const c = this.conditionFor(condition);
+    m.condition_id = c.id;
+    return { id: m.id, condition: c.finish_tag, condition_id: c.id, note: `Attached to ${c.finish_tag}.` };
+  }
   /** The exact browser save payload (TakeoffCanvas.jsx autosave + the schema key
    * store.saveAnnotations stamps) — importable by the app. */
   exportPayload() {
@@ -1816,7 +1907,7 @@ var Session = class {
       sheets: [...this.sheets.values()].filter((s) => s.upp != null).map((s) => ({ sheet_id: s.key, units_per_px: s.upp })),
       conditions: this.conditions,
       shapes: this.shapes,
-      markups: [],
+      markups: this.markups,
       sheet_group: [],
       last_group: [],
       sheet_tabs: [],
@@ -2113,6 +2204,37 @@ var sheetContextOutput = {
   }),
   hatch: z.object({ families: z.array(hatchFamilyRow), count: z.number().int() })
 };
+var annotationRow = z.object({
+  id: z.string(),
+  sheet: z.string(),
+  type: z.string(),
+  text: z.string(),
+  condition: z.string().describe("Resolved finish tag, or '' when unattached \u2014 saves joining against conditions[]"),
+  condition_id: z.string(),
+  at: z.tuple([z.number(), z.number()]).optional(),
+  target: z.tuple([z.number(), z.number()]).optional(),
+  rect: z.array(z.tuple([z.number(), z.number()]).optional()).optional()
+});
+var annotateOutput = {
+  id: z.string(),
+  sheet: z.string(),
+  type: z.string(),
+  text: z.string(),
+  condition: z.string(),
+  condition_id: z.string(),
+  note: z.string()
+};
+var listAnnotationsOutput = {
+  annotations: z.array(annotationRow),
+  count: z.number().int(),
+  unattached: z.number().int().describe("How many carry no condition \u2014 candidates for link_annotation")
+};
+var linkAnnotationOutput = {
+  id: z.string(),
+  condition: z.string(),
+  condition_id: z.string().optional(),
+  note: z.string()
+};
 
 // src/tools.ts
 var COORDS = "Coordinates are image px at render scale 2.0: PDF pt \xD7 2, origin top-left, y down (the browser canvas's native space). Sheet payloads carry dims in both px and pt.";
@@ -2311,6 +2433,39 @@ function registerTools(server, session) {
     traceToolCall("view_sheet", a, startedAt, reply);
     return reply;
   });
+  server.registerTool("annotate", {
+    description: `Place an annotation on a sheet \u2014 a note ABOUT the work, never a measurement of it. Types: cloud and highlight take rect:[[x0,y0],[x1,y1]] (a revision cloud around an area, a highlight box over it), text takes at:[x,y], callout takes at:[x,y] plus target:[x,y] (the point its leader aims at). 
+
+Pass condition to attach the note to a finish tag, which is what makes it part of that SCOPE rather than a floating remark: it then wears the condition's colour on the canvas and in the marked-set PDF, and travels with it into the report. The tag is minted on first touch like one_click/measure_polygon, so you can annotate CPT-1 before anything is traced for it. Omit condition for a note about the sheet itself. 
+
+No review gate: the pencil-not-ink rule exists to stop an agent inventing geometry, and a cloud reading "verify substrate" is not geometry. It touches no quantity. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string().describe("Sheet name or number, as sheet_info reports it"),
+      type: z2.enum(["cloud", "text", "callout", "highlight"]).describe("cloud/highlight need rect; text/callout need at; callout also needs target"),
+      text: z2.string().default("").describe("The note. A cloud with no text still reads as 'look here'"),
+      condition: z2.string().optional().describe("Finish tag to attach this note to, e.g. 'CPT-1' (minted on first use). Omit for an unattached sheet note"),
+      at: pointSchema.optional().describe("Anchor point (image px) \u2014 text and callout"),
+      target: pointSchema.optional().describe("What a callout's leader line points at (image px)"),
+      rect: z2.tuple([pointSchema, pointSchema]).optional().describe("Corners (image px) \u2014 cloud and highlight")
+    },
+    outputSchema: annotateOutput
+  }, run("annotate", (a) => session.annotate(a)));
+  server.registerTool("list_annotations", {
+    description: `Every annotation on the takeoff, with condition_id RESOLVED to its finish tag so you can act on the reply without joining against conditions[]. Filter by sheet, by condition, or both. Coordinates come back in image px (the same frame you passed in), not the normalized form they're stored as. \`unattached\` counts the notes carrying no condition \u2014 the candidates for link_annotation. ${COORDS}`,
+    inputSchema: {
+      sheet: z2.string().optional().describe("Only annotations on this sheet"),
+      condition: z2.string().optional().describe("Only annotations attached to this finish tag")
+    },
+    outputSchema: listAnnotationsOutput
+  }, run("list_annotations", (a) => session.listAnnotations(a)));
+  server.registerTool("link_annotation", {
+    description: `Attach an existing annotation to a condition, or detach it by passing an empty condition \u2014 the canvas's Attach/Detach control, reachable by an agent. Use it to tie up notes left unattached (list_annotations reports how many), or to move one to the finish it actually concerns. Attaching mints the tag on first use.`,
+    inputSchema: {
+      annotation_id: z2.string().describe("Id from annotate or list_annotations"),
+      condition: z2.string().describe("Finish tag to attach to; empty string detaches")
+    },
+    outputSchema: linkAnnotationOutput
+  }, run("link_annotation", (a) => session.linkAnnotation(a.annotation_id, a.condition)));
 }
 
 // src/resources.ts
@@ -2392,7 +2547,7 @@ function registerResources(server, session) {
 // package.json
 var package_default = {
   name: "opentakeoff-mcp",
-  version: "0.8.0",
+  version: "0.9.0",
   mcpName: "io.github.Kentucky-ai/opentakeoff",
   type: "module",
   description: "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -2443,7 +2598,12 @@ var package_default = {
     "estimating",
     "pdf",
     "quantity-takeoff",
-    "flooring"
+    "flooring",
+    "ai-agent",
+    "agentic-ai",
+    "preconstruction",
+    "construction-management",
+    "project-management"
   ],
   overrides: {
     "fast-uri": "^3.1.4",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opentakeoff-mcp",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "mcpName": "io.github.Kentucky-ai/opentakeoff",
   "type": "module",
   "description": "OpenTakeoff MCP server \u2014 drive the takeoff engine from your MCP client over stdio.",
@@ -51,10 +51,15 @@
     "estimating",
     "pdf",
     "quantity-takeoff",
-    "flooring"
+    "flooring",
+    "ai-agent",
+    "agentic-ai",
+    "preconstruction",
+    "construction-management",
+    "project-management"
   ],
   "overrides": {
     "fast-uri": "^3.1.4",
     "@hono/node-server": "^2.0.5"
   }
-}
+}