formlab-mcp 0.6.47 → 0.6.48

package/README.md

@@ -44,8 +44,8 @@ Ask Claude (or another MCP client) things like:
 | `get_batch` | Full record + actual composition, measured/derived **actual volume** (mass ÷ density, never a sum of per-ingredient volumes) and **actual mass** (yield, else summed as-prepared inputs — mL rows through that ingredient's density — else measured volume × density), **estimatedVolume** (mass ÷ the formula's finished density when no actual exists, flagged `estimate: true`), **plannedMass** for volume-target batches (target × finished density) and **formulaFinishedDensity**, the **process** method + any **process-factor values** (DOE inputs), samples + blend lineage, and — as a finished-goods lot — its storage **`location`** + finished-goods **`stockLedger`** (shipments out + adjustments; `shippedQty` total) |
 | `list_samples` | Filtered list of physical specimens |
 | `get_sample` | Full record + canonical variant + test reports + blend lineage |
-| `list_test_results` | Filtered list of test reports (by sample, parameter, **measured-value range** (`value_min`/`value_max`), date, or lab) |
-| `get_test_result` | Full report: every measurement's value, spec, any per-measurement run **conditions**, and the **resolved instrument** (`instrumentSource`: row / method / run). Complex types carry a `representative` (time-series → final, distribution → D50); a time series adds `aggregated` (per-timestamp mean ± sd) and `pointReplicates` (repeat readings at one `t`). Report-level `seriesReplicates` lists parameters measured 2+ times as separate rows — point vs series replicates are distinct. Each measurement also gives its **effective spec** (`effectiveSpec`, `specSource`: override / template / parameter / none) and `passFail` — panel and Test Method specs apply exactly as in the app, and every pass/fail count across the tools uses the same rule |
+| `list_test_results` | Filtered list of test reports (by sample, parameter, **measured-value range** (`value_min`/`value_max` — a curve at its final point, a distribution at its spec's statistic or D50), **grade** (`min_grade`/`max_grade` on a ranked scale), **text value** (`value_equals`), **run condition** (`condition`), date, or lab) |
+| `get_test_result` | Full report: every measurement's value, spec, any per-measurement run **conditions**, and the **resolved instrument** (`instrumentSource`: row / method / run). Complex types carry a `representative` (time-series → final, distribution → D50; a distribution also its `bins` and, when its spec names a statistic, `judged` at it); a ranked grade carries its `scale` and `rank`; a time series adds `aggregated` (per-timestamp mean ± sd) and `pointReplicates` (repeat readings at one `t`). Report-level `seriesReplicates` lists parameters measured 2+ times as separate rows — point vs series replicates are distinct. Each measurement also gives its **effective spec** (`effectiveSpec`, `specSource`: override / template / parameter / none) and `passFail` — panel and Test Method specs apply exactly as in the app, and every pass/fail count across the tools uses the same rule |
 | `get_doe_matrix` | Pivot matrix (CSV by default) — rows × ingredients × parameters. A parameter measured under two or more **run conditions** (storage 25 °C vs 40 °C) is one column per condition (`pH`, `pH · 40 °C`; the bare name is the base arm), never averaged together — same columns, in the same order (grouped by measurement type, the test panel's order within a group), as the app's DOE Matrix |
 | `find_failures` | Parameters ranked by failure **rate** (failing ÷ all readings; replicates in one report count once), `lowN` flag under 5 readings, plus formulations ranked by share of failing reports — same numbers as the app's Test Analytics → Failures |
 | `get_coverage_matrix` | TEST coverage by formulation, batch or sample (`grain`) × parameter. Each cell is the **latest** reading by test date (same-day reports averaged, any fail → fail) with its date and how many reports measured it; one column per **run condition** when a parameter was measured under two or more — same rollup as the app's Test Analytics → Coverage. A ranked scale shows its median grade (with its `rank`) when several readings share the date, a text result its most frequent value, a distribution with no D50 its bins; columns in the app's order (type groups, the test panel's order) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formlab-mcp",
-  "version": "0.6.47",
+  "version": "0.6.48",
   "mcpName": "io.github.juliu1980/formlab-mcp",
   "description": "Read-only Model Context Protocol server for FormLab \u2014 lets Claude (and other MCP clients) read and analyze your FormLab data, from a local export file OR your live cloud workspace.",
   "type": "module",

package/server.json

@@ -2,7 +2,7 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.juliu1980/formlab-mcp",
   "description": "Read-only MCP for FormLab — let Claude query your formulation lab. Free reads a local export; Pro connects to your live cloud workspace with a dedicated read-only token.",
-  "version": "0.6.47",
+  "version": "0.6.48",
   "websiteUrl": "https://formvix.com/mcp",
   "repository": {
     "url": "https://github.com/juliu1980/FormLab",
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "formlab-mcp",
-      "version": "0.6.47",
+      "version": "0.6.48",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/tools/analytics.js

@@ -84,7 +84,9 @@ function _mcpTsAggregate(points) {
 
 function _trimMeasurement(m, t, db) {
   const ins = _resolveInstrument(m, t, db);
-  const type = m.type || 'scalar';
+  // The app's type rule (13s): a legacy valueType 'Categorical' row is text,
+  // not a scalar.
+  const type = _mcpMeasType(m);
   // Reduce a complex type to the single representative every analysis surface
   // uses (time_series → final point, distribution → D50), and — for a series —
   // expose per-timestamp aggregation so an agent can see POINT replicates
@@ -101,6 +103,16 @@ function _trimMeasurement(m, t, db) {
   } else if (type === 'distribution' && Array.isArray(m.bins) && m.bins.length) {
     const d50 = m.bins.find(b => String(b.label || '').toUpperCase().replace(/\s/g, '') === 'D50');
     complex.representative = d50 ? { value: _round(parseFloat(d50.value), 6), basis: 'D50' } : null;
+    complex.bins = m.bins.map(b => ({ label: b.label, value: b.value }));
+    // The statistic its spec names is the one it is judged on ("D90 <=30").
+    const sp = _resolveSpec(m, t && t.templateId, db).spec;
+    if (sp && sp.stat) { const v = _mcpRepNumber(m, { dist: String(sp.stat) }); complex.judged = { value: v != null ? _round(v, 6) : null, basis: String(sp.stat) }; }
+  } else if (type === 'ordinal' && Array.isArray(m.scale) && m.scale.length) {
+    // A grade's order (13s): the scale and its place on it, so a floor like
+    // "at least HB" can be reasoned about.
+    complex.scale = m.scale.slice();
+    const r = _mcpRepNumber(m, { ordinal: 'rank' });
+    if (r != null) complex.rank = r;
   }
   return {
     parameter: m.parameter || '',
@@ -127,7 +139,7 @@ function _trimMeasurement(m, t, db) {
 const list_test_results = {
   definition: {
     name: 'list_test_results',
-    description: 'List test result reports, optionally filtered by sample, parameter, measured-value range, date range, or lab. Combine parameter + value_min/value_max to find reports whose measurement is in range (the "find by results" query, e.g. parameter="Viscosity", value_min=800, value_max=3000). Returns metadata (incl. the run-level instrument and controlSample flag) + parameters tested; use get_test_result for per-measurement values and their resolved instruments.',
+    description: 'List test result reports, optionally filtered by sample, parameter, measured-value range, grade, text value, run condition, date range, or lab. Combine parameter + value_min/value_max to find reports whose measurement is in range (the "find by results" query, e.g. parameter="Viscosity", value_min=800, value_max=3000). The number a range filter reads: a scalar as recorded, a curve at its final point, a distribution at the statistic its spec names (D90) or else D50; a ranked scale or text result has no number — use min_grade / max_grade (positions on the reading\'s own scale, e.g. parameter="Pencil hardness", min_grade="HB") or value_equals (a text result, case-insensitive). condition narrows to readings under a run condition (substring of e.g. "Storage 40 °C"; "none" = readings with no condition). Returns metadata (incl. the run-level instrument and controlSample flag) + parameters tested; use get_test_result for per-measurement values and their resolved instruments.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -135,6 +147,10 @@ const list_test_results = {
         parameter: { type: 'string', description: 'Filter to results that include this parameter (case-insensitive substring).' },
         value_min: { type: 'number', description: 'Only reports where the parameter (above) measured >= this value. Use with `parameter`; applies to any measurement if `parameter` is omitted.' },
         value_max: { type: 'number', description: 'Only reports where the parameter (above) measured <= this value. Use with `parameter`; applies to any measurement if `parameter` is omitted.' },
+        min_grade: { type: 'string', description: 'A ranked scale: only readings at or above this grade on the reading\'s own scale (e.g. "HB").' },
+        max_grade: { type: 'string', description: 'A ranked scale: only readings at or below this grade.' },
+        value_equals: { type: 'string', description: 'A text (or ranked) result equal to this value, case-insensitive (e.g. "pass", "slight haze").' },
+        condition: { type: 'string', description: 'Only readings under a run condition whose label contains this (e.g. "40 °C"); "none" = readings with no run condition.' },
         since_date: { type: 'string', description: 'ISO date — only reports on/after this date.' },
         until_date: { type: 'string', description: 'ISO date — only reports on/before this date.' },
         lab: { type: 'string', description: 'Filter by lab name (case-insensitive substring).' },
@@ -159,16 +175,32 @@ const list_test_results = {
       if (args.until_date && (t.testDate || '') > args.until_date) return false;
       if (args.lab && !norm(t.lab).includes(norm(args.lab))) return false;
       const hasRange = args.value_min != null || args.value_max != null;
-      if (args.parameter || hasRange) {
+      const hasGrade = !!(args.min_grade || args.max_grade);
+      if (args.parameter || hasRange || hasGrade || args.value_equals || args.condition) {
         const pn = norm(args.parameter);
         const found = (t.measurements || []).some(m => {
           if (args.parameter && !norm(m.parameter).includes(pn)) return false;
+          if (args.condition) {
+            const lbl = norm(_mcpCondLabel(m));
+            if (norm(args.condition) === 'none' ? lbl !== '' : !lbl.includes(norm(args.condition))) return false;
+          }
           if (hasRange) {
-            const v = _mcpRepNumber(m);   // a curve's final value, not its point count (12v)
+            // The value it is judged on (13s): a distribution at its spec's statistic.
+            const sp = _mcpMeasType(m) === 'distribution' ? (_resolveSpec(m, t.templateId, db).spec || null) : null;
+            const v = sp && sp.stat ? _mcpRepNumber(m, { dist: String(sp.stat) }) : _mcpRepNumber(m);   // a curve's final value, not its point count (12v)
             if (v == null) return false;
             if (args.value_min != null && v < args.value_min) return false;
             if (args.value_max != null && v > args.value_max) return false;
           }
+          if (hasGrade) {
+            if (_mcpMeasType(m) !== 'ordinal' || !Array.isArray(m.scale)) return false;
+            const up = m.scale.map(g => String(g).trim().toUpperCase());
+            const r = up.indexOf(String(m.value == null ? '' : m.value).trim().toUpperCase());
+            if (r < 0) return false;
+            if (args.min_grade) { const lo = up.indexOf(String(args.min_grade).trim().toUpperCase()); if (lo < 0 || r < lo) return false; }
+            if (args.max_grade) { const hi = up.indexOf(String(args.max_grade).trim().toUpperCase()); if (hi < 0 || r > hi) return false; }
+          }
+          if (args.value_equals && norm(String(m.value == null ? '' : m.value).trim()) !== norm(String(args.value_equals).trim())) return false;
           return true;
         });
         if (!found) return false;