formlab-mcp 0.1.0

package/tools/ingredients.js

@@ -0,0 +1,103 @@
+// ============================================================
+// INGREDIENT TOOLS
+//   - list_ingredients: filtered list
+//   - get_ingredient: full record incl. supplier, density, stock, cost
+// ============================================================
+
+import { getStore, resolveById } from '../data.js';
+
+function _trimIngredient(i) {
+  if (!i) return null;
+  return {
+    id: i.id,
+    uid: i.uid,
+    name: i.name,
+    family: i.family || '',
+    supplier: i.supplier || '',
+    casNumber: i.casNumber || '',
+    density: i.density != null ? i.density : null,
+    densityUnit: i.densityUnit || (i.density != null ? 'kg/L' : null),
+    costPerKg: i.costPerKg != null ? i.costPerKg : null,
+    costCurrency: i.costCurrency || (i.costPerKg != null ? 'USD' : null),
+    stockOnHand: i.stockOnHand != null ? i.stockOnHand : null,
+    stockUnit: i.stockUnit || null,
+  };
+}
+
+const list_ingredients = {
+  definition: {
+    name: 'list_ingredients',
+    description: 'List ingredients (raw materials) in the FormLab library, optionally filtered by family, supplier, or name pattern. Returns metadata; use get_ingredient for full details.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        family: { type: 'string', description: 'Filter by family (e.g. "Pigment", "Surfactant"). Case-insensitive substring.' },
+        supplier: { type: 'string', description: 'Filter by supplier name. Case-insensitive substring.' },
+        name_contains: { type: 'string', description: 'Case-insensitive substring on ingredient name.' },
+        in_stock_only: { type: 'boolean', description: 'When true, return only ingredients with stockOnHand > 0.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const limit = Math.min(1000, Math.max(1, args.limit || 100));
+    const norm = (s) => String(s || '').toLowerCase();
+    const filtered = (db.ingredients || []).filter(i => {
+      if (!i || i._trashed) return false;
+      if (args.family && !norm(i.family).includes(norm(args.family))) return false;
+      if (args.supplier && !norm(i.supplier).includes(norm(args.supplier))) return false;
+      if (args.name_contains && !norm(i.name).includes(norm(args.name_contains))) return false;
+      if (args.in_stock_only && !(i.stockOnHand > 0)) return false;
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      ingredients: filtered.slice(0, limit).map(_trimIngredient),
+    };
+  },
+};
+
+const get_ingredient = {
+  definition: {
+    name: 'get_ingredient',
+    description: 'Get full details for a single ingredient including stock movements, formulations using it, and stock-on-hand. Accepts internal id or UID (e.g. ING-001).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Internal id or UID (ING-001) of the ingredient.' },
+      },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db } = getStore();
+    const ing = resolveById('ingredients', args.id);
+    if (!ing) return { error: `No ingredient found for id "${args.id}".` };
+    // Find formulations that reference this ingredient at the TOP level
+    // (sub-formulas would need a recursive walk — list_formulations +
+    // find_similar_formulations cover that case).
+    const usedIn = (db.formulations || []).filter(f =>
+      f && !f._trashed && (f.composition || []).some(c => c && c.ingredientId === ing.id)
+    ).map(f => ({ id: f.id, uid: f.uid, name: f.name }));
+    const movements = (ing.stockMovements || []).slice(-20).map(m => ({
+      ts: m.ts,
+      reason: m.reason,
+      delta: m.delta,
+      unit: m.unit,
+      note: m.note || '',
+    }));
+    return {
+      ..._trimIngredient(ing),
+      description: ing.description || '',
+      notes: ing.notes || '',
+      attributes: ing.attributes || {},
+      formulationCount: usedIn.length,
+      formulations: usedIn.slice(0, 30),
+      recentStockMovements: movements,
+    };
+  },
+};
+
+export const tools = { list_ingredients, get_ingredient };

package/tools/lab.js

@@ -0,0 +1,234 @@
+// ============================================================
+// LAB TOOLS — batches and samples
+//   - list_batches
+//   - get_batch
+//   - list_samples
+//   - get_sample
+// ============================================================
+
+import { getStore, resolveById } from '../data.js';
+
+function _trimBatch(b, formulationsById) {
+  if (!b) return null;
+  const f = b.formulationId ? formulationsById.get(b.formulationId) : null;
+  return {
+    id: b.id,
+    uid: b.uid,
+    formulation: f ? { id: f.id, uid: f.uid, name: f.name } : null,
+    description: b.description || '',
+    status: b.status || '',
+    targetQuantity: b.targetQuantity ?? null,
+    unit: b.unit || '',
+    actualYield: b.actualYield ?? null,
+    preparedDate: b.preparedDate || '',
+    preparedBy: b.preparedBy || '',
+    process: b.process || '',
+    parentBatchId: b.parentBatchId || null,
+    isBlend: Array.isArray(b.sourceBlend) && b.sourceBlend.length > 0,
+    blendParentCount: Array.isArray(b.sourceBlend) ? b.sourceBlend.length : 0,
+  };
+}
+
+function _trimSample(s, formulationsById, batchesById) {
+  if (!s) return null;
+  const f = s.formulationId ? formulationsById.get(s.formulationId) : null;
+  const b = s.batchId ? batchesById.get(s.batchId) : null;
+  return {
+    id: s.id,
+    uid: s.uid,
+    name: s.name || '',
+    formulation: f ? { id: f.id, uid: f.uid, name: f.name } : null,
+    batch: b ? { id: b.id, uid: b.uid } : null,
+    status: s.status || '',
+    quantity: s.quantity ?? null,
+    unit: s.unit || '',
+    preparedDate: s.preparedDate || '',
+    preparedBy: s.preparedBy || '',
+    storageLocation: s.storageLocation || '',
+    isBlend: Array.isArray(s.sourceBlend) && s.sourceBlend.length > 0,
+    blendParentCount: Array.isArray(s.sourceBlend) ? s.sourceBlend.length : 0,
+    hasActualVariant: Array.isArray(s.actualVariants) && s.actualVariants.length > 0,
+  };
+}
+
+const list_batches = {
+  definition: {
+    name: 'list_batches',
+    description: 'List batches (production / lab-prep events), optionally filtered by formulation, status, or origin-only (hides batches derived from other batches). Returns metadata; use get_batch for the full consumption ledger and samples.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        formulation_id: { type: 'string', description: 'Filter to batches of this formulation (id or UID).' },
+        status: { type: 'string', description: 'Filter by status (case-insensitive substring).' },
+        origin_only: { type: 'boolean', description: 'When true, exclude batches that have a parentBatchId.' },
+        since_date: { type: 'string', description: 'ISO date (YYYY-MM-DD). Only batches prepared on/after this date.' },
+        limit: { type: 'number', description: 'Max rows (default 50, max 500).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db, indexes } = getStore();
+    const limit = Math.min(500, Math.max(1, args.limit || 50));
+    const norm = (s) => String(s || '').toLowerCase();
+    let formId = null;
+    if (args.formulation_id) {
+      const f = resolveById('formulations', args.formulation_id);
+      if (!f) return { error: `No formulation matched "${args.formulation_id}".` };
+      formId = f.id;
+    }
+    const filtered = (db.batches || []).filter(b => {
+      if (!b || b._trashed) return false;
+      if (formId && b.formulationId !== formId) return false;
+      if (args.status && !norm(b.status).includes(norm(args.status))) return false;
+      if (args.origin_only && b.parentBatchId) return false;
+      if (args.since_date && (b.preparedDate || '') < args.since_date) return false;
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      batches: filtered.slice(0, limit).map(b => _trimBatch(b, indexes.formulationsById)),
+    };
+  },
+};
+
+const get_batch = {
+  definition: {
+    name: 'get_batch',
+    description: 'Get full details for a single batch including its actual composition (as-prepared, when logged), child samples, lineage (parent / sub-blend parents), and inventory consumption note. Accepts internal id or UID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Internal id or UID (BATCH-001) of the batch.' },
+      },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db, indexes } = getStore();
+    const b = resolveById('batches', args.id);
+    if (!b) return { error: `No batch found for id "${args.id}".` };
+    const samples = (db.samples || []).filter(s => s.batchId === b.id);
+    const parents = Array.isArray(b.sourceBlend)
+      ? b.sourceBlend.map(p => {
+          if (p.batchId) {
+            const pb = indexes.batchesById.get(p.batchId);
+            return { kind: 'batch', id: p.batchId, uid: pb?.uid, amount: p.amount, unit: p.unit };
+          } else if (p.sampleId) {
+            const ps = indexes.samplesById.get(p.sampleId);
+            return { kind: 'sample', id: p.sampleId, uid: ps?.uid, amount: p.amount, unit: p.unit };
+          }
+          return p;
+        })
+      : null;
+    return {
+      ..._trimBatch(b, indexes.formulationsById),
+      notes: b.notes || '',
+      equipmentUsed: b.equipmentUsed || '',
+      actualCompositionRowCount: Array.isArray(b.actualComposition) ? b.actualComposition.length : 0,
+      hasActualComposition: Array.isArray(b.actualComposition) && b.actualComposition.length > 0,
+      sourceBlendParents: parents,
+      samples: samples.map(s => ({ id: s.id, uid: s.uid, name: s.name || '', status: s.status })),
+      sampleCount: samples.length,
+    };
+  },
+};
+
+const list_samples = {
+  definition: {
+    name: 'list_samples',
+    description: 'List samples (physical specimens), optionally filtered by batch, formulation, status, or origin (which batch they came from). Returns metadata; use get_sample for tests and variant composition.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        batch_id: { type: 'string', description: 'Filter to samples from this batch (id or UID).' },
+        formulation_id: { type: 'string', description: 'Filter to samples of this formulation (id or UID).' },
+        status: { type: 'string', description: 'Filter by status (case-insensitive substring).' },
+        is_blend_only: { type: 'boolean', description: 'When true, return only samples with sourceBlend lineage.' },
+        limit: { type: 'number', description: 'Max rows (default 100, max 1000).' },
+      },
+    },
+  },
+  handler: async (args) => {
+    const { db, indexes } = getStore();
+    const limit = Math.min(1000, Math.max(1, args.limit || 100));
+    const norm = (s) => String(s || '').toLowerCase();
+    let batchId = null, formId = null;
+    if (args.batch_id) {
+      const b = resolveById('batches', args.batch_id);
+      if (!b) return { error: `No batch matched "${args.batch_id}".` };
+      batchId = b.id;
+    }
+    if (args.formulation_id) {
+      const f = resolveById('formulations', args.formulation_id);
+      if (!f) return { error: `No formulation matched "${args.formulation_id}".` };
+      formId = f.id;
+    }
+    const filtered = (db.samples || []).filter(s => {
+      if (!s || s._trashed) return false;
+      if (batchId && s.batchId !== batchId) return false;
+      if (formId && s.formulationId !== formId) return false;
+      if (args.status && !norm(s.status).includes(norm(args.status))) return false;
+      if (args.is_blend_only && !(Array.isArray(s.sourceBlend) && s.sourceBlend.length)) return false;
+      return true;
+    });
+    return {
+      totalMatching: filtered.length,
+      returned: Math.min(filtered.length, limit),
+      samples: filtered.slice(0, limit).map(s => _trimSample(s, indexes.formulationsById, indexes.batchesById)),
+    };
+  },
+};
+
+const get_sample = {
+  definition: {
+    name: 'get_sample',
+    description: 'Get full details for a single sample including its actual variant composition, all test results bound to it, blend lineage, and storage info. Accepts internal id or UID (e.g. SAMP-0001).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', description: 'Internal id or UID of the sample.' },
+      },
+      required: ['id'],
+    },
+  },
+  handler: async (args) => {
+    const { db, indexes } = getStore();
+    const s = resolveById('samples', args.id);
+    if (!s) return { error: `No sample found for id "${args.id}".` };
+    const tests = (db.testResults || []).filter(t => t.sampleId === s.id);
+    const canonical = (s.actualVariants || []).find(v => v.isCanonical) || (s.actualVariants || [])[0] || null;
+    const parents = Array.isArray(s.sourceBlend)
+      ? s.sourceBlend.map(p => {
+          if (p.batchId) {
+            const pb = indexes.batchesById.get(p.batchId);
+            return { kind: 'batch', id: p.batchId, uid: pb?.uid, amount: p.amount, unit: p.unit };
+          } else if (p.sampleId) {
+            const ps = indexes.samplesById.get(p.sampleId);
+            return { kind: 'sample', id: p.sampleId, uid: ps?.uid, amount: p.amount, unit: p.unit };
+          }
+          return p;
+        })
+      : null;
+    return {
+      ..._trimSample(s, indexes.formulationsById, indexes.batchesById),
+      notes: s.notes || '',
+      canonicalVariant: canonical ? {
+        name: canonical.name || '',
+        isAutoSeeded: !!canonical._autoSeeded,
+        compositionRowCount: Array.isArray(canonical.composition) ? canonical.composition.length : 0,
+      } : null,
+      sourceBlendParents: parents,
+      testCount: tests.length,
+      tests: tests.map(t => ({
+        id: t.id,
+        uid: t.uid,
+        reportName: t.reportName || '',
+        testDate: t.testDate || '',
+        measurementCount: (t.measurements || []).length,
+      })),
+    };
+  },
+};
+
+export const tools = { list_batches, get_batch, list_samples, get_sample };