@humanagencyp/erp-mcp 0.1.0 → 0.2.0

package/README.md

@@ -123,8 +123,56 @@ the declared value, and the computed/expected value.
 **Postgres** — set `DATABASE_URL` to a connection string. For teams where
 multiple gateways need shared access.
 
-Schema is created automatically on first start, and a deterministic demo
-dataset is seeded when the `items` table is empty.
+Schema is created automatically on first start. An empty database is seeded
+from the company file (`ERP_COMPANY_FILE`, see below) or, without one, from a
+deterministic demo dataset.
+
+---
+
+## Simulation mode
+
+The connector has a switch, `ERP_MODE`:
+
+| Mode | What answers | Status |
+|---|---|---|
+| `simulation` (default) | the built-in simulated ERP (the database above) | available |
+| `live` | the company's real ERP | no adapter in 0.x — **every call is refused** with a clear message, nothing is read or changed |
+
+The point: a three-week test runs on exactly this connector, its tools and its
+HAP profile. Only the system behind it is simulated, so the tickets issued during
+the test are the same tickets that will be issued live. Going live = switch the
+mode and connect the real system; mandates and agent setup stay as they are.
+
+**Company file.** `ERP_COMPANY_FILE=/path/to/company.json` seeds an empty
+database with the company's items, prices, stock and customers (invented but
+realistic test data). The file is validated strictly and refused whole on the
+first problem. Example: [`examples/company.example.json`](examples/company.example.json).
+
+**Changes.** Every change the connector performs is recorded as its own entry —
+time, tool, document, status, amount, and the `receipt_id` the gateway injected.
+A document only keeps its latest `receipt_id` (sending a quote replaces the one
+from creating it), so this record, not the document, lines up ticket and effect
+one to one.
+
+**Refusals after the gateway.** When the connector refuses a change call the
+gateway already let through (false declared value, credit limit, stock, wrong
+state), it records the refusal with the `receipt_id` the gateway injected. A
+ticket then exists for an action that never happened, and this record is the
+only place that says so.
+
+**Local commands** (not MCP tools — the agent can neither read nor change them).
+Point them at the same database the gateway uses — for a gateway install that is
+`HAP_DATA_DIR=~/.suveren`:
+
+```bash
+HAP_DATA_DIR=~/.suveren erp-mcp scenario next examples/scenario.example.json   # hand over the next request, record the time
+HAP_DATA_DIR=~/.suveren erp-mcp scenario status examples/scenario.example.json
+HAP_DATA_DIR=~/.suveren erp-mcp export > record.json                          # triggers, changes, refusals, quotes + lines, orders, mode
+```
+
+The export lines up **trigger → ticket → effect**: each request's hand-over time,
+each change with the `receipt_id` of the ticket that authorised it, and each
+refusal with the `receipt_id` of the ticket whose action did not happen.
 
 ---
 

package/dist/index.js

@@ -12,6 +12,81 @@ import {
 import { existsSync, mkdirSync, copyFileSync, statSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
+
+// src/company.ts
+import { readFileSync } from "fs";
+function fail(path, msg) {
+  throw new Error(`Company file ${path}: ${msg}`);
+}
+function str(v) {
+  return typeof v === "string" && v.trim() !== "";
+}
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v);
+}
+function parseCompany(raw, path = "(inline)") {
+  if (!raw || typeof raw !== "object") fail(path, "must be a JSON object");
+  const c = raw;
+  if (!str(c.name)) fail(path, "`name` is required");
+  if (!str(c.currency) || !/^[A-Z]{3}$/.test(c.currency)) fail(path, "`currency` must be a 3-letter ISO code, e.g. EUR");
+  if (!Array.isArray(c.items) || c.items.length === 0) fail(path, "`items` must be a non-empty list");
+  if (!Array.isArray(c.customers) || c.customers.length === 0) fail(path, "`customers` must be a non-empty list");
+  const skus = /* @__PURE__ */ new Set();
+  const items = c.items.map((it, i) => {
+    const o = it ?? {};
+    const at = `items[${i}]`;
+    if (!str(o.sku)) fail(path, `${at}.sku is required`);
+    if (skus.has(o.sku)) fail(path, `${at}.sku ${JSON.stringify(o.sku)} appears twice`);
+    skus.add(o.sku);
+    if (!str(o.name)) fail(path, `${at}.name is required`);
+    if (!num(o.list_price) || o.list_price < 0) fail(path, `${at}.list_price must be a number >= 0`);
+    if (!num(o.stock) || !Number.isInteger(o.stock) || o.stock < 0) fail(path, `${at}.stock must be a whole number >= 0`);
+    return {
+      id: str(o.id) ? o.id : `item-${i + 1}`,
+      sku: o.sku,
+      name: o.name,
+      unit: str(o.unit) ? o.unit : "pcs",
+      list_price: o.list_price,
+      stock: o.stock
+    };
+  });
+  const customers = c.customers.map((cu, i) => {
+    const o = cu ?? {};
+    const at = `customers[${i}]`;
+    if (!str(o.name)) fail(path, `${at}.name is required`);
+    if (!num(o.credit_limit) || o.credit_limit < 0) fail(path, `${at}.credit_limit must be a number >= 0`);
+    const open = o.open_balance ?? 0;
+    if (!num(open) || open < 0) fail(path, `${at}.open_balance must be a number >= 0`);
+    return {
+      id: str(o.id) ? o.id : `cust-${i + 1}`,
+      name: o.name,
+      email: str(o.email) ? o.email : null,
+      country: str(o.country) ? o.country : null,
+      credit_limit: o.credit_limit,
+      open_balance: open,
+      payment_terms: str(o.payment_terms) ? o.payment_terms : null
+    };
+  });
+  for (const [label, list] of [["item", items], ["customer", customers]]) {
+    const ids = /* @__PURE__ */ new Set();
+    for (const { id } of list) {
+      if (ids.has(id)) fail(path, `${label} id ${JSON.stringify(id)} appears twice`);
+      ids.add(id);
+    }
+  }
+  return { name: c.name, currency: c.currency, items, customers };
+}
+function loadCompanyFile(path) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    fail(path, `cannot be read as JSON (${err instanceof Error ? err.message : String(err)})`);
+  }
+  return parseCompany(raw, path);
+}
+
+// src/db.ts
 var SCHEMA = `
 CREATE TABLE IF NOT EXISTS items (
   id TEXT PRIMARY KEY,
@@ -72,49 +147,106 @@ CREATE TABLE IF NOT EXISTS orders (
   updated_at TEXT DEFAULT (datetime('now')),
   receipt_id TEXT
 );
+
+-- Calls the connector refused AFTER the gateway let them through. When the gateway
+-- injected a receipt_id, a ticket exists for an action that never happened; this
+-- table is the only place that says so (the ticket alone reads like a done action).
+CREATE TABLE IF NOT EXISTS refusals (
+  id TEXT PRIMARY KEY,
+  at TEXT DEFAULT (datetime('now')),
+  tool TEXT NOT NULL,
+  receipt_id TEXT,
+  message TEXT NOT NULL
+);
+
+-- Every change the ERP performed, one row per call \u2014 the effect each ticket produced.
+-- A document's own receipt_id column holds only its latest ticket (send overwrites
+-- create), so this table, not the document, is what lines up ticket \u2194 effect 1:1.
+CREATE TABLE IF NOT EXISTS changes (
+  id TEXT PRIMARY KEY,
+  at TEXT DEFAULT (datetime('now')),
+  tool TEXT NOT NULL,
+  receipt_id TEXT,
+  document_id TEXT,
+  document_number TEXT,
+  status TEXT,
+  net_total REAL
+);
+
+-- Scenario requests handed to the agent, with the moment they were handed over.
+CREATE TABLE IF NOT EXISTS triggers (
+  scenario_id TEXT PRIMARY KEY,
+  triggered_at TEXT DEFAULT (datetime('now')),
+  request TEXT NOT NULL,
+  expected TEXT
+);
 `;
 var RECEIPT_ID_TABLES = ["quotes", "orders"];
-var SEED_ITEMS = [
-  // id, sku, name, unit, list_price, stock
-  ["item-1", "WIDGET-100", "Widget 100", "pcs", 25, 500],
-  ["item-2", "WIDGET-200", "Widget 200 Pro", "pcs", 45, 300],
-  ["item-3", "GEAR-A1", "Precision Gear A1", "pcs", 120, 80],
-  ["item-4", "GEAR-B2", "Precision Gear B2", "pcs", 150, 60],
-  ["item-5", "PANEL-S", "Control Panel S", "pcs", 89.5, 150],
-  ["item-6", "PANEL-L", "Control Panel L", "pcs", 149.5, 90],
-  ["item-7", "CABLE-5M", "Cable 5m", "pcs", 12, 1e3],
-  ["item-8", "SERVICE-KIT", "Maintenance Kit", "set", 340, 20]
-];
-var SEED_CUSTOMERS = [
-  // id, name, email, country, credit_limit, open_balance, payment_terms
-  ["cust-1", "Nordkap Manufacturing GmbH", "ap@nordkap.example", "DE", 5e4, 12e3, "NET30"],
-  ["cust-2", "Alpine Components AG", "finance@alpinecomp.example", "AT", 2e4, 4e3, "NET30"],
-  ["cust-3", "Baltic Retail Group", "accounts@balticretail.example", "LV", 8e3, 7500, "NET14"],
-  ["cust-4", "Meridian Industrial Ltd", "payables@meridianind.example", "IE", 1e5, 0, "NET60"],
-  ["cust-5", "Solstice Equipment Co", "finance@solsticeeq.example", "NL", 5e3, 4800, "NET7"]
-];
-function seedSqlite(db) {
+var DEMO_COMPANY = {
+  name: "Demo Industrial",
+  currency: "EUR",
+  items: [
+    { id: "item-1", sku: "WIDGET-100", name: "Widget 100", unit: "pcs", list_price: 25, stock: 500 },
+    { id: "item-2", sku: "WIDGET-200", name: "Widget 200 Pro", unit: "pcs", list_price: 45, stock: 300 },
+    { id: "item-3", sku: "GEAR-A1", name: "Precision Gear A1", unit: "pcs", list_price: 120, stock: 80 },
+    { id: "item-4", sku: "GEAR-B2", name: "Precision Gear B2", unit: "pcs", list_price: 150, stock: 60 },
+    { id: "item-5", sku: "PANEL-S", name: "Control Panel S", unit: "pcs", list_price: 89.5, stock: 150 },
+    { id: "item-6", sku: "PANEL-L", name: "Control Panel L", unit: "pcs", list_price: 149.5, stock: 90 },
+    { id: "item-7", sku: "CABLE-5M", name: "Cable 5m", unit: "pcs", list_price: 12, stock: 1e3 },
+    { id: "item-8", sku: "SERVICE-KIT", name: "Maintenance Kit", unit: "set", list_price: 340, stock: 20 }
+  ],
+  customers: [
+    { id: "cust-1", name: "Nordkap Manufacturing GmbH", email: "ap@nordkap.example", country: "DE", credit_limit: 5e4, open_balance: 12e3, payment_terms: "NET30" },
+    { id: "cust-2", name: "Alpine Components AG", email: "finance@alpinecomp.example", country: "AT", credit_limit: 2e4, open_balance: 4e3, payment_terms: "NET30" },
+    { id: "cust-3", name: "Baltic Retail Group", email: "accounts@balticretail.example", country: "LV", credit_limit: 8e3, open_balance: 7500, payment_terms: "NET14" },
+    { id: "cust-4", name: "Meridian Industrial Ltd", email: "payables@meridianind.example", country: "IE", credit_limit: 1e5, open_balance: 0, payment_terms: "NET60" },
+    { id: "cust-5", name: "Solstice Equipment Co", email: "finance@solsticeeq.example", country: "NL", credit_limit: 5e3, open_balance: 4800, payment_terms: "NET7" }
+  ]
+};
+var INSERT_ITEM = `INSERT INTO items (id, sku, name, unit, list_price, currency, stock) VALUES (?, ?, ?, ?, ?, ?, ?)`;
+var INSERT_CUSTOMER = `INSERT INTO customers (id, name, email, country, currency, credit_limit, open_balance, payment_terms) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`;
+function companyRows(company) {
+  return {
+    items: company.items.map((i) => [i.id, i.sku, i.name, i.unit, i.list_price, company.currency, i.stock]),
+    customers: company.customers.map((c) => [
+      c.id,
+      c.name,
+      c.email,
+      c.country,
+      company.currency,
+      c.credit_limit,
+      c.open_balance,
+      c.payment_terms
+    ])
+  };
+}
+function resolveCompany(env = process.env) {
+  const path = env.ERP_COMPANY_FILE?.trim();
+  return path ? loadCompanyFile(path) : DEMO_COMPANY;
+}
+function seedSqlite(db, company) {
   const { count } = db.prepare("SELECT COUNT(*) as count FROM items").get();
-  if (count > 0) return;
-  const insertItem = db.prepare(
-    `INSERT INTO items (id, sku, name, unit, list_price, currency, stock) VALUES (?, ?, ?, ?, ?, 'EUR', ?)`
-  );
-  for (const [id, sku, name, unit, listPrice, stock] of SEED_ITEMS) {
-    insertItem.run(id, sku, name, unit, listPrice, stock);
-  }
-  const insertCustomer = db.prepare(
-    `INSERT INTO customers (id, name, email, country, currency, credit_limit, open_balance, payment_terms) VALUES (?, ?, ?, ?, 'EUR', ?, ?, ?)`
-  );
-  for (const [id, name, email, country, creditLimit, openBalance, terms] of SEED_CUSTOMERS) {
-    insertCustomer.run(id, name, email, country, creditLimit, openBalance, terms);
+  if (count > 0) {
+    if (process.env.ERP_COMPANY_FILE) {
+      console.error("[erp-mcp] database already holds data \u2014 ERP_COMPANY_FILE not loaded (start from an empty database to load it)");
+    }
+    return;
   }
+  const rows = companyRows(company);
+  const insertItem = db.prepare(INSERT_ITEM);
+  const insertCustomer = db.prepare(INSERT_CUSTOMER);
+  db.transaction(() => {
+    for (const r of rows.items) insertItem.run(...r);
+    for (const r of rows.customers) insertCustomer.run(...r);
+  })();
+  console.error(`[erp-mcp] seeded "${company.name}": ${company.items.length} items, ${company.customers.length} customers`);
 }
-async function createSqliteDb(dbPath) {
+async function createSqliteDb(dbPath, company) {
   const { default: Database } = await import("better-sqlite3");
   const db = new Database(dbPath);
   db.pragma("foreign_keys = ON");
   db.exec(SCHEMA);
-  seedSqlite(db);
+  seedSqlite(db, company);
   for (const table of RECEIPT_ID_TABLES) {
     const cols = db.prepare(`PRAGMA table_info(${table})`).all();
     if (!cols.some((c) => c.name === "receipt_id")) {
@@ -136,7 +268,7 @@ async function createSqliteDb(dbPath) {
     }
   };
 }
-async function createPostgresDb(connectionString) {
+async function createPostgresDb(connectionString, company) {
   const { default: pg } = await import("pg");
   const pool = new pg.Pool({ connectionString });
   function adaptSql(sql) {
@@ -152,18 +284,9 @@ async function createPostgresDb(connectionString) {
     }
     const { rows } = await client.query("SELECT COUNT(*)::int as count FROM items");
     if (rows[0].count === 0) {
-      for (const [id, sku, name, unit, listPrice, stock] of SEED_ITEMS) {
-        await client.query(
-          `INSERT INTO items (id, sku, name, unit, list_price, currency, stock) VALUES ($1, $2, $3, $4, $5, 'EUR', $6)`,
-          [id, sku, name, unit, listPrice, stock]
-        );
-      }
-      for (const [id, name, email, country, creditLimit, openBalance, terms] of SEED_CUSTOMERS) {
-        await client.query(
-          `INSERT INTO customers (id, name, email, country, currency, credit_limit, open_balance, payment_terms) VALUES ($1, $2, $3, $4, 'EUR', $5, $6, $7)`,
-          [id, name, email, country, creditLimit, openBalance, terms]
-        );
-      }
+      const seed = companyRows(company);
+      for (const r of seed.items) await client.query(adaptSql(INSERT_ITEM), r);
+      for (const r of seed.customers) await client.query(adaptSql(INSERT_CUSTOMER), r);
     }
   } finally {
     client.release();
@@ -198,22 +321,36 @@ function maybeBackupSqlite(dbPath) {
     }
   }
 }
-async function createDb() {
+async function createDb(company = resolveCompany()) {
   const databaseUrl = process.env.DATABASE_URL ?? "";
   if (databaseUrl.startsWith("postgres://") || databaseUrl.startsWith("postgresql://")) {
     console.error("[erp-mcp] using Postgres");
-    return createPostgresDb(databaseUrl);
+    return createPostgresDb(databaseUrl, company);
   }
-  const hapDir = process.env.HAP_DATA_DIR ?? join(homedir(), ".hap");
-  if (!existsSync(hapDir)) {
-    mkdirSync(hapDir, { recursive: true });
+  let dbPath = databaseUrl;
+  if (!dbPath) {
+    const hapDir = process.env.HAP_DATA_DIR ?? join(homedir(), ".hap");
+    if (!existsSync(hapDir)) mkdirSync(hapDir, { recursive: true });
+    dbPath = join(hapDir, "erp.db");
   }
-  const dbPath = databaseUrl || join(hapDir, "erp.db");
   maybeBackupSqlite(dbPath);
   console.error(`[erp-mcp] using SQLite at ${dbPath}`);
-  return createSqliteDb(dbPath);
+  return createSqliteDb(dbPath, company);
 }
 
+// src/dispatch.ts
+import { randomUUID } from "crypto";
+
+// src/mode.ts
+var MODES = ["simulation", "live"];
+function getMode(env = process.env) {
+  const raw = (env.ERP_MODE ?? "").trim().toLowerCase();
+  if (raw === "") return "simulation";
+  if (MODES.includes(raw)) return raw;
+  throw new Error(`ERP_MODE must be one of ${MODES.join(", ")} \u2014 got ${JSON.stringify(env.ERP_MODE)}.`);
+}
+var LIVE_NOT_AVAILABLE = "Refused: this ERP connector is in live mode, but no live ERP adapter is installed (0.x ships the simulation only). Nothing was read or changed. Set ERP_MODE=simulation, or install the adapter for your ERP.";
+
 // src/tools/items.ts
 async function list_items(db, args) {
   const { query, limit = 50 } = args;
@@ -520,6 +657,160 @@ async function get_order(db, args) {
   return orderWithLines(db, id);
 }
 
+// src/dispatch.ts
+var CHANGE_TOOLS = /* @__PURE__ */ new Set(["create_quote", "update_quote", "send_quote", "convert_quote_to_order"]);
+async function runTool(db, name, args) {
+  switch (name) {
+    case "list_items":
+      return list_items(db, args);
+    case "get_item":
+      return get_item(db, args);
+    case "find_customers":
+      return find_customers(db, args);
+    case "get_customer":
+      return get_customer(db, args);
+    case "list_quotes":
+      return list_quotes(db, args);
+    case "get_quote":
+      return get_quote(db, args);
+    case "list_orders":
+      return list_orders(db, args);
+    case "get_order":
+      return get_order(db, args);
+    case "create_quote":
+      return create_quote(db, args);
+    case "update_quote":
+      return update_quote(db, args);
+    case "send_quote":
+      return send_quote(db, args);
+    case "convert_quote_to_order":
+      return convert_quote_to_order(db, args);
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+async function callTool(db, mode, name, args) {
+  if (mode === "live") throw new Error(LIVE_NOT_AVAILABLE);
+  try {
+    const result = await runTool(db, name, args);
+    if (CHANGE_TOOLS.has(name)) {
+      const doc = result ?? {};
+      await db.run(
+        `INSERT INTO changes (id, at, tool, receipt_id, document_id, document_number, status, net_total) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          randomUUID(),
+          (/* @__PURE__ */ new Date()).toISOString(),
+          name,
+          typeof args.receipt_id === "string" ? args.receipt_id : null,
+          doc.id ?? null,
+          doc.number ?? null,
+          doc.status ?? null,
+          typeof doc.net_total === "number" ? doc.net_total : null
+        ]
+      );
+    }
+    return result;
+  } catch (err) {
+    if (CHANGE_TOOLS.has(name)) {
+      const message = err instanceof Error ? err.message : String(err);
+      const receiptId = typeof args.receipt_id === "string" ? args.receipt_id : null;
+      await db.run(`INSERT INTO refusals (id, at, tool, receipt_id, message) VALUES (?, ?, ?, ?, ?)`, [
+        randomUUID(),
+        (/* @__PURE__ */ new Date()).toISOString(),
+        name,
+        receiptId,
+        message
+      ]);
+    }
+    throw err;
+  }
+}
+
+// src/cli.ts
+import { readFileSync as readFileSync2 } from "fs";
+function loadScenario(path) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (err) {
+    throw new Error(`Scenario file ${path} cannot be read as JSON (${err instanceof Error ? err.message : String(err)})`);
+  }
+  const list = raw?.requests;
+  if (!Array.isArray(list) || list.length === 0) throw new Error(`Scenario file ${path}: \`requests\` must be a non-empty list`);
+  const ids = /* @__PURE__ */ new Set();
+  return list.map((r, i) => {
+    if (typeof r?.id !== "string" || !r.id.trim()) throw new Error(`Scenario file ${path}: requests[${i}].id is required`);
+    if (ids.has(r.id)) throw new Error(`Scenario file ${path}: request id ${JSON.stringify(r.id)} appears twice`);
+    ids.add(r.id);
+    if (typeof r.request !== "string" || !r.request.trim()) throw new Error(`Scenario file ${path}: requests[${i}].request is required`);
+    return { id: r.id, request: r.request, expected: r.expected };
+  });
+}
+async function nextRequest(db, scenario) {
+  const done = new Set((await db.all(`SELECT scenario_id FROM triggers`)).map((r) => r.scenario_id));
+  const next = scenario.find((r) => !done.has(r.id));
+  if (!next) return null;
+  await db.run(`INSERT INTO triggers (scenario_id, request, expected) VALUES (?, ?, ?)`, [
+    next.id,
+    next.request,
+    next.expected === void 0 ? null : JSON.stringify(next.expected)
+  ]);
+  const row = await db.get(`SELECT triggered_at FROM triggers WHERE scenario_id = ?`, [next.id]);
+  return { ...next, triggered_at: row.triggered_at };
+}
+async function exportRecord(db, mode = getMode()) {
+  const quotes = await db.all(`SELECT * FROM quotes ORDER BY created_at, number`);
+  const lines = await db.all(`SELECT * FROM quote_lines`);
+  const byQuote = /* @__PURE__ */ new Map();
+  for (const l of lines) byQuote.set(l.quote_id, [...byQuote.get(l.quote_id) ?? [], l]);
+  return {
+    mode,
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    triggers: (await db.all(`SELECT * FROM triggers ORDER BY triggered_at`)).map((t) => ({
+      ...t,
+      expected: t.expected ? JSON.parse(t.expected) : null
+    })),
+    quotes: quotes.map((q) => ({ ...q, lines: byQuote.get(q.id) ?? [] })),
+    orders: await db.all(`SELECT * FROM orders ORDER BY created_at, number`),
+    changes: await db.all(`SELECT * FROM changes ORDER BY at`),
+    refusals: await db.all(`SELECT * FROM refusals ORDER BY at`)
+  };
+}
+var USAGE = `usage: erp-mcp export | erp-mcp scenario next <file> | erp-mcp scenario status <file>`;
+async function runCli(argv) {
+  const [cmd, sub, file] = argv;
+  try {
+    if (cmd === "export") {
+      const db = await createDb();
+      process.stdout.write(JSON.stringify(await exportRecord(db), null, 2) + "\n");
+      await db.close();
+      return 0;
+    }
+    if (cmd === "scenario" && (sub === "next" || sub === "status") && file) {
+      const scenario = loadScenario(file);
+      const db = await createDb();
+      if (sub === "next") {
+        const next = await nextRequest(db, scenario);
+        process.stdout.write(next ? `[${next.id}] handed over ${next.triggered_at} UTC
+${next.request}
+` : "All requests handed over.\n");
+      } else {
+        const done = new Map((await db.all(`SELECT scenario_id, triggered_at FROM triggers`)).map((r) => [r.scenario_id, r.triggered_at]));
+        for (const r of scenario) process.stdout.write(`${r.id}	${done.get(r.id) ?? "pending"}	${r.request}
+`);
+      }
+      await db.close();
+      return 0;
+    }
+    process.stderr.write(USAGE + "\n");
+    return 2;
+  } catch (err) {
+    process.stderr.write(`[erp-mcp] ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+
 // src/index.ts
 var RECEIPT_FIELD = {
   type: "string",
@@ -698,9 +989,14 @@ var TOOL_DEFINITIONS = [
   }
 ];
 async function main() {
+  if (process.argv.length > 2) {
+    process.exit(await runCli(process.argv.slice(2)));
+  }
+  const mode = getMode();
   const db = await createDb();
+  console.error(`[erp-mcp] mode: ${mode}`);
   const server = new Server(
-    { name: "erp", version: "0.1.0" },
+    { name: "erp", version: "0.2.0" },
     { capabilities: { tools: {} } }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -710,47 +1006,7 @@ async function main() {
     const { name, arguments: args } = request.params;
     const safeArgs = args ?? {};
     try {
-      let result;
-      switch (name) {
-        case "list_items":
-          result = await list_items(db, safeArgs);
-          break;
-        case "get_item":
-          result = await get_item(db, safeArgs);
-          break;
-        case "find_customers":
-          result = await find_customers(db, safeArgs);
-          break;
-        case "get_customer":
-          result = await get_customer(db, safeArgs);
-          break;
-        case "list_quotes":
-          result = await list_quotes(db, safeArgs);
-          break;
-        case "get_quote":
-          result = await get_quote(db, safeArgs);
-          break;
-        case "list_orders":
-          result = await list_orders(db, safeArgs);
-          break;
-        case "get_order":
-          result = await get_order(db, safeArgs);
-          break;
-        case "create_quote":
-          result = await create_quote(db, safeArgs);
-          break;
-        case "update_quote":
-          result = await update_quote(db, safeArgs);
-          break;
-        case "send_quote":
-          result = await send_quote(db, safeArgs);
-          break;
-        case "convert_quote_to_order":
-          result = await convert_quote_to_order(db, safeArgs);
-          break;
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
+      const result = await callTool(db, mode, name, safeArgs);
       return {
         content: [
           {

package/examples/company.example.json

@@ -0,0 +1,13 @@
+{
+  "name": "Bergmann Ersatzteile GmbH",
+  "currency": "EUR",
+  "items": [
+    { "sku": "SP-100", "name": "Hydraulic seal kit", "unit": "set", "list_price": 84.5, "stock": 40 },
+    { "sku": "SP-200", "name": "Bearing set 6204", "unit": "set", "list_price": 120.0, "stock": 10 },
+    { "sku": "SP-310", "name": "Drive belt XPZ 1250", "unit": "pcs", "list_price": 18.9, "stock": 250 }
+  ],
+  "customers": [
+    { "name": "Huber Maschinenbau GmbH", "email": "einkauf@huber.example", "country": "AT", "credit_limit": 15000, "open_balance": 2000, "payment_terms": "NET30" },
+    { "name": "Steiner Anlagentechnik KG", "email": "office@steiner.example", "country": "DE", "credit_limit": 4000, "open_balance": 3500, "payment_terms": "NET14" }
+  ]
+}

package/examples/scenario.example.json

@@ -0,0 +1,8 @@
+{
+  "requests": [
+    { "id": "r1", "request": "Huber Maschinenbau asks for 10 × Hydraulic seal kit (SP-100), delivery next week.",
+      "expected": { "customer_id": "cust-1", "lines": [{ "item_id": "item-1", "qty": 10 }], "value": 845 } },
+    { "id": "r2", "request": "Steiner Anlagentechnik asks for 5 × Bearing set 6204 (SP-200).",
+      "expected": { "customer_id": "cust-2", "lines": [{ "item_id": "item-2", "qty": 5 }], "value": 600, "note": "an order would exceed the credit limit (3,500 open + 600 > 4,000)" } }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanagencyp/erp-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "ERP MCP server for the Human Agency Protocol — quote-to-order: items, customers, quotes, orders",
   "license": "MIT",
   "repository": {