formlab-mcp 0.6.45 → 0.6.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formlab-mcp",
-  "version": "0.6.45",
+  "version": "0.6.46",
   "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.45",
+  "version": "0.6.46",
   "websiteUrl": "https://formvix.com/mcp",
   "repository": {
     "url": "https://github.com/juliu1980/FormLab",
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "formlab-mcp",
-      "version": "0.6.45",
+      "version": "0.6.46",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

package/tools/analytics.js

@@ -1437,7 +1437,7 @@ const get_stability = {
   },
 };
 
-export { _mcpRepNumber, _mcpMeasType, _evalPassFail, _resolveSpec, _shelfLife, _shelfLifeAssess, _mcpCondTags, _mcpArmNames, _mcpCondDefaultScore };
+export { _mcpRepNumber, _mcpMeasType, _evalPassFail, _resolveSpec, _shelfLife, _shelfLifeAssess, _mcpCondTags, _mcpArmNames, _mcpCondDefaultScore, _mcpCondSig, _mcpCondLabel, _mcpParamGroupsOf };
 // ============================================================
 // compare_test_results — the app's Compare Results table (js/views/testing-
 // compare.js), 13g. Items are formulas, batches, samples or test reports; each

package/tools/designspace.js

@@ -27,7 +27,7 @@
 // ============================================================
 
 import { getStore, resolveById, flattenComposition } from '../data.js';
-import { _mcpRepNumber } from './analytics.js';
+import { _mcpRepNumber, _mcpMeasType } from './analytics.js';
 
 // ---- composition helper -----------------------------------------------------
 // Ingredient wt-% map for one formula, mirroring the app's _asmIngredientMap:
@@ -346,20 +346,24 @@ function _roleCandidates(forms, roleMaps) {
   return out.sort((a, b) => b.score - a.score);
 }
 // A formula's value for a measured parameter, as the app's
-// _asmFormulaValueForCol (12v): readings of the primary run condition (the one
-// with the most readings), each as the DOE Matrix reads it (a curve's final
-// value, a distribution's D50, an ordinal's rank), then their mean.
+// _asmFormulaValueForCol: the plain-name readings — no run condition when
+// there are any (13q; it took the condition with the most readings), else the
+// most readings — each read as the DOE Matrix reads it (a curve's final value,
+// a distribution's D50, a grade's place on its scale), then their mean; a
+// ranked scale's middle grade (lower median), never an averaged rank.
 function _paramValue(f, param, db) {
   const sids = new Set((db.samples || []).filter(s => s.formulationId === f.id).map(s => s.id));
   const ms = [];
   (db.testResults || []).forEach(t => { if (!sids.has(t.sampleId)) return; (t.measurements || []).forEach(m => { if (m.parameter === param) ms.push(m); }); });
   const sig = (m) => { const c = m && m.conditions; return c && typeof c === 'object' ? Object.keys(c).filter(k => c[k] != null && c[k] !== '').sort().map(k => k + '=' + c[k]).join('; ') : ''; };
   const byCond = new Map();
-  ms.forEach(m => { if (_mcpRepNumber(m) == null) return; const k = sig(m); byCond.set(k, (byCond.get(k) || 0) + 1); });
-  const primary = [...byCond.entries()].sort((a, b) => b[1] - a[1])[0];
+  ms.forEach(m => { if (_mcpRepNumber(m, { ordinal: 'rank' }) == null) return; const k = sig(m); byCond.set(k, (byCond.get(k) || 0) + 1); });
+  const primary = [...byCond.entries()].sort((a, b) => ((a[0] ? 1 : 0) - (b[0] ? 1 : 0)) || (b[1] - a[1]) || a[0].localeCompare(b[0]))[0];
   const pool = primary ? ms.filter(m => sig(m) === primary[0]) : ms;
   const vals = pool.map(m => _mcpRepNumber(m, { ordinal: 'rank' })).filter(v => v != null);
-  return vals.length ? vals.reduce((a, b) => a + b, 0) / vals.length : null;
+  if (!vals.length) return null;
+  if (pool.some(m => _mcpMeasType(m) === 'ordinal')) { const so = vals.slice().sort((a, b) => a - b); return so[Math.floor((so.length - 1) / 2)]; }
+  return vals.reduce((a, b) => a + b, 0) / vals.length;
 }
 function _spearman(xs, ys) {
   const rank = (a) => { const idx = a.map((v, i) => [v, i]).sort((p, q) => p[0] - q[0]); const r = new Array(a.length); let i = 0; while (i < idx.length) { let j = i; while (j + 1 < idx.length && idx[j + 1][0] === idx[i][0]) j++; const avg = (i + j) / 2 + 1; for (let k = i; k <= j; k++) r[idx[k][1]] = avg; i = j + 1; } return r; };
@@ -503,7 +507,7 @@ const get_design_space = {
       if (vals.length < 2) out.notes.push(`"${args.property}" is measured on ${vals.length} of the formulas on the map — need at least 2 for insights (check the exact parameter name).`);
       else {
         const hi = vals.reduce((a, b) => b.v > a.v ? b : a), lo = vals.reduce((a, b) => b.v < a.v ? b : a);
-        const pi = { property: args.property, basis: 'mean of every reading per formula', formulasMeasured: vals.length,
+        const pi = { property: args.property, basis: 'per formula: the readings with no run condition (else the condition tested most) — the mean, a curve at its final point, a distribution at its D50; a ranked scale as its middle grade\'s place on the scale', formulasMeasured: vals.length,
           highest: { formula: hi.f.name, uid: hi.f.uid || null, value: +hi.v.toFixed(4) },
           lowest: { formula: lo.f.name, uid: lo.f.uid || null, value: +lo.v.toFixed(4) } };
         if (vals.length >= 4) {

package/tools/library.js

@@ -12,7 +12,7 @@
 // ============================================================
 
 import { getStore, resolveById } from '../data.js';
-import { _evalPassFail } from './analytics.js';
+import { _evalPassFail, _mcpRepNumber, _mcpMeasType, _resolveSpec, _mcpCondSig, _mcpCondLabel, _mcpCondTags, _mcpParamGroupsOf } from './analytics.js';
 
 // ── Usage roll-ups (mirror the Usage tabs on the Panel / Method / Equipment
 //    detail pages) ────────────────────────────────────────────────────────
@@ -26,7 +26,23 @@ function _resolveInstrument(m, t, db) {
   if (t && (t.equipmentId || t.instrument)) return { equipmentId: t.equipmentId || '', name: t.instrument || '', source: 'run' };
   return { equipmentId: '', name: '', source: '' };
 }
-function _num(m) { const v = parseFloat(m && m.value); return Number.isFinite(v) ? v : null; }
+// A reading's number, the app's rule (13q): a curve's final point, a
+// distribution at the statistic its spec names (D90) or D50, nothing for a
+// grade or text. It was parseFloat(m.value): a curve's point count, "6B" → 6.
+function _num(m, t) {
+  if (!m) return null;
+  const sp = _mcpMeasType(m) === 'distribution' ? (_resolveSpec(m, t && t.templateId).spec || null) : null;
+  const v = sp && sp.stat ? _mcpRepNumber(m, { dist: String(sp.stat) }) : _mcpRepNumber(m);
+  return v != null && Number.isFinite(v) ? v : null;
+}
+// Condition tags for one parameter's arms ('' first): { key → "40 °C" }, only
+// when there are two or more.
+function _condTagMap(keys) {
+  const ks = [...new Set(keys)].sort((x, y) => ((x ? 1 : 0) - (y ? 1 : 0)) || x.localeCompare(y));
+  if (ks.length < 2) return new Map();
+  const tags = _mcpCondTags(ks.map(k => k ? k.split('|').map(p => p.replace('=', ' ')).join(' · ') : ''));
+  return new Map(ks.map((k, i) => [k, tags[i]]));
+}
 function _mean(a) { return a.length ? a.reduce((x, y) => x + y, 0) / a.length : null; }
 function _sd(a) { if (a.length < 2) return null; const mu = _mean(a); return Math.sqrt(a.reduce((acc, x) => acc + (x - mu) ** 2, 0) / (a.length - 1)); }
 function _r(v, d = 3) { return v == null ? null : +v.toFixed(d); }
@@ -163,18 +179,32 @@ const get_equipment = {
     const nm = _norm(e.name);
     const mine = (m, t) => { const r = _resolveInstrument(m, t, db); return r.equipmentId ? r.equipmentId === e.id : (!!nm && _norm(r.name) === nm); };
     const tests = (db.testResults || []).filter(t => (t.measurements || []).some(m => mine(m, t)));
-    const here = new Map(), fleet = new Map();
+    // Per parameter × RUN CONDITION (13q, as the app): a unit that ran the
+    // 40 °C pulls was compared with everyone's ambient readings.
+    const here = new Map(), fleet = new Map(), pairs = [];
     (db.testResults || []).forEach(t => (t.measurements || []).forEach(m => {
       const pn = (m.parameter || '').trim(); if (!pn) return;
-      const v = _num(m); const isMine = mine(m, t); const bucket = isMine ? here : fleet;
-      if (!bucket.has(pn)) bucket.set(pn, { parameter: pn, readings: 0, vals: [], fails: 0 });
-      const g = bucket.get(pn); g.readings++; if (v != null) g.vals.push(v); if (isMine && _evalPassFail(m, t.templateId) === 'fail') g.fails++;
+      const cond = _mcpCondSig(m);
+      const v = _num(m, t); const isMine = mine(m, t); const bucket = isMine ? here : fleet;
+      if (isMine) pairs.push({ m, t });
+      const k = pn + '\u0000' + cond;
+      if (!bucket.has(k)) bucket.set(k, { k, parameter: pn, cond, m0: m, readings: 0, vals: [], fails: 0 });
+      const g = bucket.get(k); g.readings++; if (v != null) g.vals.push(v); if (isMine && _evalPassFail(m, t.templateId) === 'fail') g.fails++;
     }));
-    const measured = [...here.values()].map(g => {
-      const f = fleet.get(g.parameter); const mh = _mean(g.vals), me = f ? _mean(f.vals) : null;
-      return { parameter: g.parameter, readings: g.readings, mean: _r(mh), fails: g.fails, readingsElsewhere: f ? f.readings : 0, meanElsewhere: _r(me),
-        biasPct: (mh != null && me != null && me !== 0) ? _r((mh - me) / Math.abs(me) * 100, 1) : null };
-    }).sort((a, b) => b.readings - a.readings);
+    // The app's order: type groups, the test panel's order; no condition first.
+    const order = _mcpParamGroupsOf(pairs, 'method', db).flatMap(g => g.parameters);
+    const oi = (pn) => { const i = order.indexOf(pn); return i < 0 ? 1e6 : i; };
+    const tagsBy = new Map();
+    here.forEach(g => { if (!tagsBy.has(g.parameter)) tagsBy.set(g.parameter, []); tagsBy.get(g.parameter).push(g.cond); });
+    const measured = [...here.values()]
+      .sort((a, b) => (oi(a.parameter) - oi(b.parameter)) || ((a.cond ? 1 : 0) - (b.cond ? 1 : 0)) || a.cond.localeCompare(b.cond))
+      .map(g => {
+        const f = fleet.get(g.k); const mh = _mean(g.vals), me = f ? _mean(f.vals) : null;
+        const tag = _condTagMap(tagsBy.get(g.parameter)).get(g.cond);
+        return { parameter: g.parameter, ...(g.cond ? { condition: _mcpCondLabel(g.m0), ...(tag ? { column: `${g.parameter} · ${tag}` } : {}) } : {}),
+          readings: g.readings, mean: _r(mh), fails: g.fails, readingsElsewhere: f ? f.readings : 0, meanElsewhere: _r(me),
+          biasPct: (mh != null && me != null && me !== 0) ? _r((mh - me) / Math.abs(me) * 100, 1) : null };
+      });
     const usedIn = _equipUsage(e, db);
     usedIn.testReports = tests.length;
     return { ...(_trimEquipment(e)), usedIn, usage: _usageRollup(db, tests, mine), measured };
@@ -278,15 +308,28 @@ const get_test_method = {
     // Usage = every measurement linked to this method (by id, else by exact name).
     const match = (m) => (m.parameterId && m.parameterId === p.id) || (!m.parameterId && _norm(m.parameter) === nm);
     const tests = (db.testResults || []).filter(r => (r.measurements || []).some(match));
-    const vals = [], byInst = new Map();
+    // Values by RUN CONDITION (13q, as the app): the summary is the plain-name
+    // condition (no condition when there is any, else the most readings), with
+    // byCondition when there are two or more; byInstrument within a condition.
+    const byCond = new Map(), byInst = new Map(), condM = new Map();
     tests.forEach(r => (r.measurements || []).filter(match).forEach(m => {
-      const v = _num(m); if (v != null) vals.push(v);
-      const inst = _resolveInstrument(m, r, db); const key = inst.name || inst.equipmentId || '(unresolved)';
-      if (!byInst.has(key)) byInst.set(key, { instrument: key, readings: 0, vals: [], fails: 0 });
+      const cond = _mcpCondSig(m); if (!condM.has(cond)) condM.set(cond, m);
+      const v = _num(m, r);
+      if (!byCond.has(cond)) byCond.set(cond, []);
+      if (v != null) byCond.get(cond).push(v);
+      const inst = _resolveInstrument(m, r, db); const ik = inst.name || inst.equipmentId || '(unresolved)';
+      const key = ik + '\u0000' + cond;
+      if (!byInst.has(key)) byInst.set(key, { instrument: ik, cond, readings: 0, vals: [], fails: 0 });
       const g = byInst.get(key); g.readings++; if (v != null) g.vals.push(v); if (_evalPassFail(m, r.templateId) === 'fail') g.fails++;
     }));
-    const byInstrument = [...byInst.values()].map(g => ({ instrument: g.instrument, readings: g.readings, mean: _r(_mean(g.vals)), fails: g.fails })).sort((a, b) => b.readings - a.readings);
-    const valueSummary = { readings: vals.length, mean: _r(_mean(vals)), sd: _r(_sd(vals)), min: vals.length ? Math.min(...vals) : null, max: vals.length ? Math.max(...vals) : null, unit: p.defaultUnit || '' };
+    const conds = [...byCond.keys()].sort((x, y) => ((x ? 1 : 0) - (y ? 1 : 0)) || (byCond.get(y).length - byCond.get(x).length) || x.localeCompare(y));
+    const primary = conds.length ? conds[0] : '';
+    const sum = (vals) => ({ readings: vals.length, mean: _r(_mean(vals)), sd: _r(_sd(vals)), min: vals.length ? Math.min(...vals) : null, max: vals.length ? Math.max(...vals) : null });
+    const condName = (c) => c ? _mcpCondLabel(condM.get(c)) : null;
+    const byInstrument = [...byInst.values()].map(g => ({ instrument: g.instrument, ...(conds.length > 1 ? { condition: condName(g.cond) } : {}), readings: g.readings, mean: _r(_mean(g.vals)), fails: g.fails })).sort((a, b) => b.readings - a.readings);
+    const valueSummary = { ...sum(byCond.get(primary) || []), unit: p.defaultUnit || '',
+      ...(conds.length > 1 ? { condition: condName(primary), note: 'measured under more than one run condition: this summary is the readings with no condition (else the condition with the most readings); byCondition has each, never averaged together',
+        byCondition: conds.map(c => ({ condition: condName(c), ...sum(byCond.get(c)) })) } : {}) };
     return { ...(_trimMethod(p, { full: true })), analyteSiblings: siblings, usingPanels, usage: _usageRollup(db, tests, match), valueSummary, byInstrument };
   },
 };