formlab-mcp 0.6.32 → 0.6.33

package/README.md

@@ -45,9 +45,9 @@ Ask Claude (or another MCP client) things like:
 | `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 |
-| `get_doe_matrix` | Pivot matrix (CSV by default) — rows × ingredients × parameters |
+| `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 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 — same rollup as the app's Test Analytics → Coverage |
+| `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 |
 | `compare_batches` | Reproducibility of 2+ runs (ideally of one formula): each run's **yield %**, actual produced mass, cost/kg; per-ingredient **drift** across the runs vs the formula's proposed wt-%; and the biggest **outlier** run. `basis`: `wt_percent` (default) or `amount` |
 | `get_batch_pivot` | Production analytics — aggregate batches by `group_by` (formula / status / month / prepared_by / project) × `metric` (count, avg_yield_pct, total_produced_kg, avg_cost_per_batch, total_samples, total_tests), with share + total for additive metrics. Optional `batch_uids` scope + `status` filter |
 | `get_project_pivot` | Portfolio analytics — aggregate projects by `group_by` (status / phase / priority / business_unit / site / customer / lead, or `cf:<custom field>`) × `metric` (count, total_formulas / batches / samples, total_cost, avg_formulas / batches / cost_per_batch), rolling child activity + cost up by any project attribute. Optional `project_uids` scope |

package/package.json

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

package/tools/analytics.js

@@ -226,7 +226,7 @@ const get_test_result = {
 const get_doe_matrix = {
   definition: {
     name: 'get_doe_matrix',
-    description: 'Build a Design-of-Experiments style pivot matrix: rows = formulations (or samples / batches / tests), columns = composition wt-% per ingredient + aggregated test-parameter values. Same shape as the FormLab DOE Matrix view. Returns CSV when format=csv (default) for compact LLM consumption, or structured JSON when format=json.',
+    description: 'Build a Design-of-Experiments style pivot matrix: rows = formulations (or samples / batches / tests), columns = composition wt-% per ingredient + aggregated test-parameter values. Same shape as the FormLab DOE Matrix view. A parameter measured under two or more RUN CONDITIONS (e.g. storage 25 °C vs 40 °C) is one column per condition — "pH · 40 °C" — and the bare parameter column is the base arm (readings with no condition, else the condition with the most readings); they are different responses, never averaged together. Returns CSV when format=csv (default) for compact LLM consumption, or structured JSON when format=json.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -335,11 +335,22 @@ const get_doe_matrix = {
       const ing = indexes.ingredientsById.get(id);
       return { id, label: (ing?.name || id) + ' (%)' };
     });
-    const paramCols = [...parameters].map(p => ({ id: p, label: p }));
+    // One column per parameter, or per (parameter, run condition) when it was
+    // measured under two or more conditions — see _mcpArmNames.
+    const armNames = _mcpArmNames(rows.flatMap(r => r.measurements
+      .filter(m => m && m.parameter && parameters.has(m.parameter))
+      .map(m => ({ parameter: m.parameter, m }))));
+    const paramCols = [];
+    [...parameters].forEach(p => {
+      const arms = armNames.get(p);
+      if (!arms) { paramCols.push({ id: p, cond: null, label: p }); return; }
+      arms.forEach((label, sig) => paramCols.push({ id: p, cond: sig, label }));
+    });
 
-    // 4) Aggregate measurements per param per row (mean of numeric scalar values)
-    const cellParamValue = (r, param) => {
-      const ms = r.measurements.filter(m => m.parameter === param);
+    // 4) Aggregate measurements per column per row (mean of numeric scalar
+    //    values), reading only the column's own run condition when split.
+    const cellParamValue = (r, col) => {
+      const ms = r.measurements.filter(m => m.parameter === col.id && (col.cond == null || _mcpCondSig(m) === col.cond));
       if (!ms.length) return null;
       const nums = ms.map(m => parseFloat(m.value)).filter(v => isFinite(v));
       if (!nums.length) return ms[0].value ?? null;
@@ -360,7 +371,7 @@ const get_doe_matrix = {
         rows: limitedRows.map(r => ({
           label: r.label,
           ingredientPct: Object.fromEntries(ingCols.map(c => [c.label, r.composition.get(c.id) ?? null])),
-          parameterMean: Object.fromEntries(paramCols.map(c => [c.label, cellParamValue(r, c.id)])),
+          parameterMean: Object.fromEntries(paramCols.map(c => [c.label, cellParamValue(r, c)])),
         })),
       };
     }
@@ -377,7 +388,7 @@ const get_doe_matrix = {
       const cells = [
         r.label,
         ...ingCols.map(c => r.composition.get(c.id) ?? ''),
-        ...paramCols.map(c => cellParamValue(r, c.id) ?? ''),
+        ...paramCols.map(c => cellParamValue(r, c) ?? ''),
       ];
       lines.push(cells.map(escCSV).join(','));
     });
@@ -414,6 +425,57 @@ function _mcpCondSig(m) {
   if (!c || typeof c !== 'object') return '';
   return Object.keys(c).filter(k => c[k] != null && c[k] !== '').sort().map(k => `${k}=${c[k]}`).join('|');
 }
+// ---- Run-condition ARMS (mirror the app, FormLab 1.16.18 build 24h–24i) ----
+// A parameter measured under two or more run conditions (storage 25 °C vs
+// 40 °C, first vs second heat) is one column per condition in the DOE Matrix
+// and the Coverage matrix: an ambient arm and an accelerated one are different
+// responses, never averaged. The bare parameter name keeps the BASE arm — the
+// readings with no condition when there are any, otherwise the arm with the
+// most readings (the arm a bare `pH` means in the app's search) — and the
+// others read "pH · 40 °C". Same rule and the same tag shortening as the app
+// (js/utils.js flCondTags), so column names match what the user sees.
+function _mcpCondLabel(m) {
+  const c = m && m.conditions;
+  if (!c || typeof c !== 'object') return '';
+  return Object.entries(c).filter(([, v]) => v != null && v !== '').map(([k, v]) => `${k} ${v}`).join(' · ');
+}
+function _mcpCondTags(conds) {
+  const named = conds.filter(Boolean);
+  let pre = '';
+  if (named.length > 1) {
+    const first = named[0];
+    let i = 0;
+    while (i < first.length && named.every(c => c[i] === first[i])) i++;
+    pre = first.slice(0, i);
+    pre = pre.slice(0, pre.lastIndexOf(' ') + 1);
+  }
+  const tags = conds.map(c => c ? (c.slice(pre.length) || c) : 'no condition');
+  const lead = tags.map(t => t.split(/\s+[\/·]\s+/)[0]);
+  return (new Set(lead).size === lead.length) ? lead : tags;
+}
+// items: [{ parameter, m }] → Map(parameter → Map(condSig → column name)),
+// only for parameters with two or more arms.
+function _mcpArmNames(items) {
+  const arms = new Map();
+  for (const it of items) {
+    const sig = _mcpCondSig(it.m);
+    if (!arms.has(it.parameter)) arms.set(it.parameter, new Map());
+    const a = arms.get(it.parameter);
+    const cur = a.get(sig) || { n: 0, m: it.m };
+    cur.n++; a.set(sig, cur);
+  }
+  const out = new Map();
+  arms.forEach((a, param) => {
+    if (a.size < 2) return;
+    const keys = [...a.keys()];
+    const base = a.has('') ? '' : keys.slice().sort((x, y) => (a.get(y).n - a.get(x).n) || x.localeCompare(y))[0];
+    const ordered = [base, ...keys.filter(k => k !== base).sort((x, y) => x.localeCompare(y))];
+    const tags = _mcpCondTags(ordered.map(k => k ? _mcpCondLabel(a.get(k).m) : ''));
+    out.set(param, new Map(ordered.map((k, i) => [k, i === 0 ? param : `${param} · ${tags[i]}`])));
+  });
+  return out;
+}
+
 function _mcpFlattenReadings(tests, indexes, paramFilter) {
   const norm = (s) => String(s || '').toLowerCase();
   const groups = new Map(); const order = [];
@@ -613,7 +675,7 @@ function _evalPassFail(m, templateId, db) {
 const get_coverage_matrix = {
   definition: {
     name: 'get_coverage_matrix',
-    description: 'Coverage matrix matching the app\'s Test Analytics → Coverage: rows = sample, batch or formulation (grain), columns = parameters. Each cell is the LATEST reading by test date; readings from several reports on that same date are averaged and fail if any of them fails. Each cell also gives latestDate, reportsAveraged and nReports (how many reports measured it). Empty = never tested. Use for "what\'s untested", "what\'s the current value" and "what\'s been measured many times".',
+    description: 'Coverage matrix matching the app\'s Test Analytics → Coverage: rows = sample, batch or formulation (grain), columns = parameters — one column per RUN CONDITION when a parameter was measured under two or more (e.g. "pH" and "pH · 40 °C"; the bare name is the base arm), never averaged together. Each cell is the LATEST reading by test date; readings from several reports on that same date are averaged and fail if any of them fails. Each cell also gives latestDate, reportsAveraged and nReports (how many reports measured it). Empty = never tested. Use for "what\'s untested", "what\'s the current value" and "what\'s been measured many times".',
     inputSchema: {
       type: 'object',
       properties: {
@@ -650,7 +712,7 @@ const get_coverage_matrix = {
     if (fmt === 'json') {
       return {
         grain, rowCount: sorted.length, parameterCount: paramCols.length, parameters: paramCols,
-        rule: 'cell = latest reading by test date; same-date reports averaged (any fail → fail)',
+        rule: 'cell = latest reading by test date; same-date reports averaged (any fail → fail); one column per run condition, never averaged across',
         rows: sorted.map(r => ({ [grain]: r.label, id: r.uid, cells: Object.fromEntries([...r.cells.entries()].sort()) })),
       };
     }
@@ -671,6 +733,15 @@ const get_coverage_matrix = {
 
 // Latest-date rollup (mirrors the app's _taCoverageRows).
 function _mcpCoverageRows(flat, grain, indexes) {
+  // One column per run condition first (see _mcpArmNames), so "latest" never
+  // means whichever storage arm was pulled last and a shared date never
+  // averages ambient with accelerated.
+  const armNames = _mcpArmNames(flat);
+  if (armNames.size) flat = flat.map(r => {
+    const map = armNames.get(r.parameter);
+    const nm = map && map.get(_mcpCondSig(r.m));
+    return (!nm || nm === r.parameter) ? r : { ...r, parameter: nm };
+  });
   const rows = new Map();
   for (const r of flat) {
     let rec = null, label = '';
@@ -693,8 +764,12 @@ function _mcpCoverageRows(flat, grain, indexes) {
       const nums = list.map(x => x.numeric).filter(v => v != null && isFinite(v));
       const mean = nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : null;
       const pf = list.some(x => x.pf === 'fail') ? 'fail' : list.some(x => x.pf === 'pass') ? 'pass' : list[0].pf;
+      // Replicate means carry float dust ((5.9 + 5.9 + 5.9) / 3 = 5.900000000000001);
+      // an agent should read the number the user sees. 12 significant digits
+      // keeps every real value.
+      const tidy = (v) => (typeof v === 'number' && isFinite(v)) ? Number(v.toPrecision(12)) : v;
       row.cells.set(param, {
-        value: list.length === 1 ? (list[0].numeric != null ? list[0].numeric : list[0].value) : (mean != null ? mean : list[0].value),
+        value: tidy(list.length === 1 ? (list[0].numeric != null ? list[0].numeric : list[0].value) : (mean != null ? mean : list[0].value)),
         unit: list[0].unit, pf: (pf === 'pass' || pf === 'fail') ? pf : null,
         latestDate: date || null, reportsAveraged: list.length, nReports: row.reports.get(param).size,
       });
@@ -1154,7 +1229,7 @@ const get_stability = {
   },
 };
 
-export { _evalPassFail, _resolveSpec, _shelfLife, _shelfLifeAssess };
+export { _evalPassFail, _resolveSpec, _shelfLife, _shelfLifeAssess, _mcpCondTags, _mcpArmNames };
 export const tools = {
   list_test_results,
   get_test_result,