@ansvar/ch-farm-safety-mcp 0.1.0

package/src/tools/search-safety-rules.ts

@@ -0,0 +1,35 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import { ftsSearch, type Database } from '../db.js';
+
+interface SearchArgs {
+  query: string;
+  topic?: string;
+  jurisdiction?: string;
+  limit?: number;
+}
+
+export function handleSearchSafetyRules(db: Database, args: SearchArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  const limit = Math.min(args.limit ?? 20, 50);
+  let results = ftsSearch(db, args.query, limit);
+
+  if (args.topic) {
+    results = results.filter(r => r.area.toLowerCase() === args.topic!.toLowerCase());
+  }
+
+  return {
+    query: args.query,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results: results.map(r => ({
+      title: r.title,
+      body: r.body,
+      area: r.area,
+      relevance_rank: r.rank,
+    })),
+    _meta: buildMeta(),
+  };
+}

package/tests/db.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createTestDatabase } from './helpers/seed-db.js';
+import { ftsSearch, tieredFtsSearch, type Database } from '../src/db.js';
+
+let db: Database;
+
+beforeAll(() => {
+  db = createTestDatabase();
+});
+
+afterAll(() => {
+  db.close();
+});
+
+describe('database schema', () => {
+  it('creates all expected tables', () => {
+    const tables = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'search_index%' AND name != 'sqlite_stat1' ORDER BY name"
+    );
+    const names = tables.map(t => t.name);
+    expect(names).toContain('safety_rules');
+    expect(names).toContain('risk_assessments');
+    expect(names).toContain('machinery_safety');
+    expect(names).toContain('chemical_safety');
+    expect(names).toContain('young_worker_rules');
+    expect(names).toContain('accident_reporting');
+    expect(names).toContain('bul_guidance');
+    expect(names).toContain('db_metadata');
+  });
+
+  it('creates FTS5 virtual table', () => {
+    const fts = db.get<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='search_index'"
+    );
+    expect(fts).toBeDefined();
+    expect(fts!.name).toBe('search_index');
+  });
+
+  it('stores schema version in db_metadata', () => {
+    const version = db.get<{ value: string }>(
+      "SELECT value FROM db_metadata WHERE key = 'schema_version'"
+    );
+    expect(version).toBeDefined();
+    expect(version!.value).toBe('1.0');
+  });
+
+  it('stores mcp_name in db_metadata', () => {
+    const name = db.get<{ value: string }>(
+      "SELECT value FROM db_metadata WHERE key = 'mcp_name'"
+    );
+    expect(name).toBeDefined();
+    expect(name!.value).toBe('Switzerland Farm Safety MCP');
+  });
+
+  it('enforces area CHECK constraint on safety_rules', () => {
+    expect(() => {
+      db.run(
+        "INSERT INTO safety_rules (topic, rule, area) VALUES ('test', 'test', 'invalid_area')"
+      );
+    }).toThrow();
+  });
+});
+
+describe('ftsSearch', () => {
+  it('returns results for a matching query', () => {
+    const results = ftsSearch(db, 'Traktor');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0]).toHaveProperty('title');
+    expect(results[0]).toHaveProperty('body');
+    expect(results[0]).toHaveProperty('area');
+    expect(results[0]).toHaveProperty('rank');
+  });
+
+  it('returns empty array for non-matching query', () => {
+    const results = ftsSearch(db, 'xyznonexistent');
+    expect(results).toEqual([]);
+  });
+
+  it('respects limit parameter', () => {
+    const results = ftsSearch(db, 'Sicherheit', 2);
+    expect(results.length).toBeLessThanOrEqual(2);
+  });
+});
+
+describe('tieredFtsSearch', () => {
+  it('returns tier information with results', () => {
+    const { tier, results } = tieredFtsSearch(db, 'search_index', ['title', 'body', 'area', 'jurisdiction'], 'ROPS');
+    expect(tier).toBeTruthy();
+    expect(tier).not.toBe('empty');
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it('returns empty tier for empty query', () => {
+    const { tier, results } = tieredFtsSearch(db, 'search_index', ['title', 'body', 'area', 'jurisdiction'], '');
+    expect(tier).toBe('empty');
+    expect(results).toEqual([]);
+  });
+
+  it('falls through tiers for partial matches', () => {
+    const { tier, results } = tieredFtsSearch(db, 'search_index', ['title', 'body', 'area', 'jurisdiction'], 'Zapfwelle Schutz');
+    expect(results.length).toBeGreaterThan(0);
+    // Should match via AND, prefix, or another tier
+    expect(['phrase', 'and', 'prefix', 'stemmed', 'or', 'like']).toContain(tier);
+  });
+});
+
+describe('database wrapper', () => {
+  it('get returns undefined for missing row', () => {
+    const result = db.get<{ value: string }>(
+      "SELECT value FROM db_metadata WHERE key = 'nonexistent'"
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it('all returns empty array for no matches', () => {
+    const results = db.all<{ id: number }>(
+      "SELECT * FROM safety_rules WHERE topic = 'nonexistent'"
+    );
+    expect(results).toEqual([]);
+  });
+});

package/tests/helpers/seed-db.ts

@@ -0,0 +1,134 @@
+import { createDatabase, type Database } from '../../src/db.js';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+/**
+ * Create a temporary in-memory-like test database with seed data.
+ * Uses a temp file because better-sqlite3 FTS5 needs a real file.
+ */
+export function createTestDatabase(): Database {
+  const dbPath = join(tmpdir(), `ch-farm-safety-test-${randomUUID()}.db`);
+  const db = createDatabase(dbPath);
+
+  // --- safety_rules ---
+  const insertSafetyRule = `
+    INSERT INTO safety_rules (topic, rule, area, description, source, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `;
+  const safetyRules = [
+    ['Traktor ROPS', 'Ueberrollschutz (ROPS) ist obligatorisch auf allen Traktoren', 'maschinen', 'Alle Traktoren muessen mit einem geprueften ROPS ausgeruestet sein. Sicherheitsgurt tragen.', 'BUL Lebenswichtige Regeln', 'DE', 'CH'],
+    ['Zapfwellenschutz', 'Zapfwelle muss vollstaendig verkleidet sein', 'maschinen', 'Rotierende Zapfwellen muessen mit geeignetem Schutz abgedeckt sein. Niemals offene Zapfwellen beruehren.', 'BUL Lebenswichtige Regeln', 'DE', 'CH'],
+    ['Silogas Gefahr', 'Silo niemals alleine betreten', 'silogas', 'Silogase (CO2, NO2) koennen toedlich sein. Immer zu zweit arbeiten und Gasmelder verwenden.', 'Suva Merkblatt', 'DE', 'CH'],
+    ['Tierhaltung Fluchtweg', 'Fluchtmoeglichkeit bei Grossvieh sicherstellen', 'tiere', 'Bei Arbeiten mit Rindern und Pferden muss immer ein Fluchtweg vorhanden sein.', 'BUL Lebenswichtige Regeln', 'DE', 'CH'],
+    ['Absturzsicherung', 'Absturzsicherung ab 2 Meter Hoehe', 'hoehe', 'Ab einer Absturzhoehe von 2 Metern sind Sicherungsmassnahmen wie Gelaender oder Gurte obligatorisch.', 'EKAS Richtlinie', 'DE', 'CH'],
+    ['Pflanzenschutzmittel PSA', 'Schutzausruestung bei PSM-Anwendung tragen', 'chemie', 'Bei der Anwendung von Pflanzenschutzmitteln ist die vorgeschriebene persoenliche Schutzausruestung zu tragen.', 'Suva / BUL', 'DE', 'CH'],
+    ['Holzerei Sicherheitsabstand', 'Sicherheitsabstand bei Baumfaellarbeiten einhalten', 'wald', 'Mindestabstand von 2 Baumlaengen bei Faellarbeiten. Rueckzugsweg planen.', 'BUL Lebenswichtige Regeln', 'DE', 'CH'],
+    ['Allgemeine Sicherheitsregeln', 'Betriebsanleitung vor Inbetriebnahme lesen', 'allgemein', 'Jede Maschine und jedes Geraet muss gemaess Betriebsanleitung bedient werden.', 'EKAS', 'DE', 'CH'],
+  ];
+  for (const rule of safetyRules) {
+    db.run(insertSafetyRule, rule);
+  }
+
+  // --- Populate FTS search_index from safety_rules ---
+  const rules = db.all<{ topic: string; description: string; area: string; jurisdiction: string }>(
+    'SELECT topic, COALESCE(description, rule) as description, area, jurisdiction FROM safety_rules'
+  );
+  for (const r of rules) {
+    db.run(
+      'INSERT INTO search_index (title, body, area, jurisdiction) VALUES (?, ?, ?, ?)',
+      [r.topic, r.description, r.area, r.jurisdiction]
+    );
+  }
+
+  // --- risk_assessments ---
+  const insertRiskAssessment = `
+    INSERT INTO risk_assessments (activity_type, requirement, content, update_trigger, legal_basis, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `;
+  const riskAssessments = [
+    ['Alleinarbeit', 'Risikobeurteilung obligatorisch', 'Alleinarbeit mit erhoehtem Risiko erfordert schriftliche Risikobeurteilung und Notfallkonzept.', 'Bei Aenderung der Arbeitsorganisation', 'VUV Art. 8, EKAS 6508', 'DE', 'CH'],
+    ['Siloarbeiten', 'Gasmelder und Begleitperson', 'Vor Betreten des Silos: Belueftung, Gasmessung, zweite Person als Sicherungsposten.', 'Jaehrlich oder nach Zwischenfall', 'VUV Art. 3, BUL Merkblatt Silogas', 'DE', 'CH'],
+    ['Tierhaltung', 'Umgang mit Grossvieh beurteilen', 'Risikobeurteilung fuer Tierhaltung umfasst Fluchtweg, Fixiereinrichtungen, Erste-Hilfe-Material.', 'Bei neuem Tierbestand oder Stallumbau', 'VUV Art. 3-10', 'DE', 'CH'],
+  ];
+  for (const ra of riskAssessments) {
+    db.run(insertRiskAssessment, ra);
+  }
+
+  // --- machinery_safety ---
+  const insertMachinery = `
+    INSERT INTO machinery_safety (machine_type, requirement, certification, notes, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `;
+  const machinerySafety = [
+    ['Traktor', 'ROPS obligatorisch, Sicherheitsgurt tragen, MFK alle 4 Jahre', 'MFK / Typenpruefung', 'Gilt fuer alle Traktoren ab Baujahr 1970. Ausnahme: historische Traktoren mit Sonderbewilligung.', 'DE', 'CH'],
+    ['Motorsaege', 'Schnittschutzhose, Helm mit Gehoerschutz und Visier, Schnittschutzstiefel', 'CE-Kennzeichnung', 'Nur geschulte Personen. BUL-Kurs empfohlen.', 'DE', 'CH'],
+    ['Kreiselmaeher', 'Schutzvorrichtung gegen Steinschlag, Abstand zu Personen', 'CE-Kennzeichnung', 'Mindestabstand 50 Meter zu Personen waehrend des Betriebs.', 'DE', 'CH'],
+  ];
+  for (const ms of machinerySafety) {
+    db.run(insertMachinery, ms);
+  }
+
+  // --- chemical_safety ---
+  const insertChemical = `
+    INSERT INTO chemical_safety (substance_type, exposure_limit, ppe_required, storage_rule, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `;
+  const chemicalSafety = [
+    ['Pflanzenschutzmittel', 'Produktspezifisch (siehe Sicherheitsdatenblatt)', 'Schutzhandschuhe, Schutzbrille, Schutzanzug, Atemschutz je nach Produkt', 'Verschlossener Giftschrank, getrennt von Lebens- und Futtermitteln, Auffangwanne', 'DE', 'CH'],
+    ['Silogas', 'CO2: MAK 5000 ppm / NO2: MAK 0.5 ppm', 'Atemschutzgeraet (Isoliergeraet), Gaswarngeraet', 'Silo nach Befuellung 3 Wochen nicht betreten. Belueftung sicherstellen.', 'DE', 'CH'],
+    ['Ammoniak', 'MAK 20 ppm (14 mg/m3)', 'Atemschutz (Gasfilter K), Schutzbrille, Handschuhe', 'Belueftete Raeume, Notdusche in der Naehe', 'DE', 'CH'],
+  ];
+  for (const cs of chemicalSafety) {
+    db.run(insertChemical, cs);
+  }
+
+  // --- young_worker_rules ---
+  const insertYoungWorker = `
+    INSERT INTO young_worker_rules (age_group, restriction, exception, legal_basis, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `;
+  const youngWorkerRules = [
+    ['unter-13', 'Keine Arbeit erlaubt', 'Leichte Hilfstaetigkeiten auf dem eigenen Familienbetrieb ab 13 Jahren moeglich', 'ArG Art. 30, ArGV 5 Art. 8', 'DE', 'CH'],
+    ['13-15', 'Leichte Arbeiten, keine gefaehrlichen Taetigkeiten, max. 3h/Tag waehrend Schulzeit', 'Familienbetrieb: erleichterte Regeln, aber kein Umgang mit gefaehrlichen Maschinen', 'ArGV 5 Art. 9-11', 'DE', 'CH'],
+    ['15-18', 'Keine Alleinarbeit mit Grossvieh, keine Motorsaege ohne Ausbildung, keine Siloarbeiten', 'Ab 16 mit Berufsbildung: erweiterte Taetigkeiten unter Aufsicht moeglich', 'ArGV 5 Art. 4, Anhang 2', 'DE', 'CH'],
+  ];
+  for (const yw of youngWorkerRules) {
+    db.run(insertYoungWorker, yw);
+  }
+
+  // --- accident_reporting ---
+  const insertAccidentReporting = `
+    INSERT INTO accident_reporting (severity, obligation, deadline, form, insurer, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `;
+  const accidentReporting = [
+    ['toedlich', 'Sofortige Meldung an Polizei und Suva/Privatversicherer', 'Sofort', 'Telefonische Meldung, dann Suva-Formular', 'Suva (Angestellte) / Privatversicherer (Selbstaendige)', 'DE', 'CH'],
+    ['schwer', 'Meldung an Versicherer innert 3 Tagen', '3 Arbeitstage', 'Unfallmeldung UVG (Suva-Formular oder Privatversicherer)', 'Suva (Angestellte) / Privatversicherer (Selbstaendige)', 'DE', 'CH'],
+    ['leicht', 'Meldung wenn Arbeitsunfaehigkeit >3 Tage', 'Innert 3 Arbeitstagen nach Kenntnis', 'Unfallmeldung UVG', 'Suva (Angestellte) / Privatversicherer (Selbstaendige)', 'DE', 'CH'],
+  ];
+  for (const ar of accidentReporting) {
+    db.run(insertAccidentReporting, ar);
+  }
+
+  // --- bul_guidance ---
+  const insertBulGuidance = `
+    INSERT INTO bul_guidance (topic, title, description, url, language, jurisdiction)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `;
+  const bulGuidance = [
+    ['Maschinen', 'Lebenswichtige Regeln Maschinen', 'Die 8 lebenswichtigen Regeln fuer den sicheren Umgang mit landwirtschaftlichen Maschinen.', 'https://www.bul.ch/de/themen/maschinen', 'DE', 'CH'],
+    ['Tiere', 'Sicherer Umgang mit Grossvieh', 'Merkblatt zum sicheren Umgang mit Rindern, Pferden und anderen Grosstieren.', 'https://www.bul.ch/de/themen/tierhaltung', 'DE', 'CH'],
+    ['Wald', 'Sicherheit bei Holzerei', 'Regeln fuer sichere Waldarbeit: Faelltechnik, Schutzausruestung, Rettungskette.', 'https://www.bul.ch/de/themen/wald', 'DE', 'CH'],
+    ['Safe@Work', 'Safe@Work Kampagne Landwirtschaft', 'Praeventionskampagne fuer junge Landwirte und Lernende in der Landwirtschaft.', 'https://www.bul.ch/de/themen/safeatwork', 'DE', 'CH'],
+  ];
+  for (const bg of bulGuidance) {
+    db.run(insertBulGuidance, bg);
+  }
+
+  // --- db_metadata ---
+  db.run("INSERT OR REPLACE INTO db_metadata (key, value) VALUES ('last_ingest', '2026-04-05')");
+  db.run("INSERT OR REPLACE INTO db_metadata (key, value) VALUES ('build_date', '2026-04-05')");
+
+  return db;
+}

package/tests/jurisdiction.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { validateJurisdiction, SUPPORTED_JURISDICTIONS } from '../src/jurisdiction.js';
+
+describe('validateJurisdiction', () => {
+  it('accepts CH', () => {
+    const result = validateJurisdiction('CH');
+    expect(result.valid).toBe(true);
+    if (result.valid) {
+      expect(result.jurisdiction).toBe('CH');
+    }
+  });
+
+  it('accepts lowercase ch', () => {
+    const result = validateJurisdiction('ch');
+    expect(result.valid).toBe(true);
+    if (result.valid) {
+      expect(result.jurisdiction).toBe('CH');
+    }
+  });
+
+  it('defaults to CH when undefined', () => {
+    const result = validateJurisdiction(undefined);
+    expect(result.valid).toBe(true);
+    if (result.valid) {
+      expect(result.jurisdiction).toBe('CH');
+    }
+  });
+
+  it('rejects unsupported jurisdiction', () => {
+    const result = validateJurisdiction('DE');
+    expect(result.valid).toBe(false);
+    if (!result.valid) {
+      expect(result.error.error).toBe('jurisdiction_not_supported');
+      expect(result.error.supported).toEqual(SUPPORTED_JURISDICTIONS);
+    }
+  });
+
+  it('rejects empty string by defaulting to CH', () => {
+    // Empty string normalised to '' which is not in supported list, but toUpperCase of '' is ''
+    const result = validateJurisdiction('');
+    // '' is not 'CH', so this should fail
+    expect(result.valid).toBe(false);
+  });
+});
+
+describe('SUPPORTED_JURISDICTIONS', () => {
+  it('contains CH', () => {
+    expect(SUPPORTED_JURISDICTIONS).toContain('CH');
+  });
+
+  it('is a readonly array', () => {
+    expect(Array.isArray(SUPPORTED_JURISDICTIONS)).toBe(true);
+  });
+});

package/tests/tools/about.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { handleAbout } from '../../src/tools/about.js';
+
+describe('about tool', () => {
+  const result = handleAbout();
+
+  it('returns server name', () => {
+    expect(result.name).toBe('Switzerland Farm Safety MCP');
+  });
+
+  it('returns version', () => {
+    expect(result.version).toBe('0.1.0');
+  });
+
+  it('includes CH in jurisdictions', () => {
+    expect(result.jurisdiction).toContain('CH');
+  });
+
+  it('returns data sources', () => {
+    expect(result.data_sources).toBeInstanceOf(Array);
+    expect(result.data_sources.length).toBeGreaterThan(0);
+    const joined = result.data_sources.join(' ');
+    expect(joined).toContain('BUL');
+    expect(joined).toContain('Suva');
+    expect(joined).toContain('EKAS');
+    expect(joined).toContain('Agriss');
+  });
+
+  it('returns tool count of 10', () => {
+    expect(result.tools_count).toBe(10);
+  });
+
+  it('includes links', () => {
+    expect(result.links).toHaveProperty('homepage');
+    expect(result.links).toHaveProperty('repository');
+    expect(result.links).toHaveProperty('mcp_network');
+  });
+
+  it('includes _meta with disclaimer', () => {
+    expect(result._meta).toHaveProperty('disclaimer');
+    expect(result._meta.disclaimer.length).toBeGreaterThan(50);
+    expect(result._meta).toHaveProperty('server', 'ch-farm-safety-mcp');
+  });
+});

package/tests/tools/check-freshness.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createTestDatabase } from '../helpers/seed-db.js';
+import { handleCheckFreshness } from '../../src/tools/check-freshness.js';
+import type { Database } from '../../src/db.js';
+
+let db: Database;
+
+beforeAll(() => {
+  db = createTestDatabase();
+});
+
+afterAll(() => {
+  db.close();
+});
+
+describe('check_data_freshness tool', () => {
+  it('returns freshness status', () => {
+    const result = handleCheckFreshness(db);
+    expect(['fresh', 'stale', 'unknown']).toContain(result.status);
+  });
+
+  it('returns last_ingest date from seed data', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.last_ingest).toBe('2026-04-05');
+  });
+
+  it('returns build_date from seed data', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.build_date).toBe('2026-04-05');
+  });
+
+  it('returns schema_version', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.schema_version).toBe('1.0');
+  });
+
+  it('calculates days_since_ingest as a number', () => {
+    const result = handleCheckFreshness(db);
+    expect(typeof result.days_since_ingest).toBe('number');
+    expect(result.days_since_ingest).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns staleness_threshold_days of 90', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.staleness_threshold_days).toBe(90);
+  });
+
+  it('returns refresh_command', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.refresh_command).toContain('ingest.yml');
+  });
+
+  it('includes _meta', () => {
+    const result = handleCheckFreshness(db);
+    expect(result._meta).toBeDefined();
+    expect(result._meta).toHaveProperty('server', 'ch-farm-safety-mcp');
+  });
+
+  it('reports unknown when last_ingest is missing', () => {
+    // Create a DB without last_ingest
+    const tmpDb = createTestDatabase();
+    tmpDb.run("DELETE FROM db_metadata WHERE key = 'last_ingest'");
+    const result = handleCheckFreshness(tmpDb);
+    expect(result.status).toBe('unknown');
+    expect(result.days_since_ingest).toBeNull();
+    tmpDb.close();
+  });
+});

package/tests/tools/list-sources.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createTestDatabase } from '../helpers/seed-db.js';
+import { handleListSources } from '../../src/tools/list-sources.js';
+import type { Database } from '../../src/db.js';
+
+let db: Database;
+
+beforeAll(() => {
+  db = createTestDatabase();
+});
+
+afterAll(() => {
+  db.close();
+});
+
+describe('list_sources tool', () => {
+  it('returns an array of sources', () => {
+    const result = handleListSources(db);
+    expect(result.sources).toBeInstanceOf(Array);
+    expect(result.sources.length).toBeGreaterThan(0);
+  });
+
+  it('includes BUL/SPAA source', () => {
+    const result = handleListSources(db);
+    const bul = result.sources.find(s => s.name.includes('BUL'));
+    expect(bul).toBeDefined();
+    expect(bul!.authority).toContain('BUL');
+    expect(bul!.official_url).toContain('bul.ch');
+  });
+
+  it('includes Suva source', () => {
+    const result = handleListSources(db);
+    const suva = result.sources.find(s => s.name.includes('Suva'));
+    expect(suva).toBeDefined();
+    expect(suva!.official_url).toContain('suva.ch');
+  });
+
+  it('includes EKAS source', () => {
+    const result = handleListSources(db);
+    const ekas = result.sources.find(s => s.name.includes('EKAS'));
+    expect(ekas).toBeDefined();
+  });
+
+  it('includes Agriss source', () => {
+    const result = handleListSources(db);
+    const agriss = result.sources.find(s => s.name.includes('Agriss'));
+    expect(agriss).toBeDefined();
+  });
+
+  it('each source has required fields', () => {
+    const result = handleListSources(db);
+    for (const source of result.sources) {
+      expect(source).toHaveProperty('name');
+      expect(source).toHaveProperty('authority');
+      expect(source).toHaveProperty('official_url');
+      expect(source).toHaveProperty('retrieval_method');
+      expect(source).toHaveProperty('license');
+      expect(source).toHaveProperty('coverage');
+    }
+  });
+
+  it('populates last_retrieved from db_metadata', () => {
+    const result = handleListSources(db);
+    // Seed data has last_ingest = 2026-04-05
+    for (const source of result.sources) {
+      expect(source.last_retrieved).toBe('2026-04-05');
+    }
+  });
+
+  it('includes _meta', () => {
+    const result = handleListSources(db);
+    expect(result._meta).toBeDefined();
+    expect(result._meta).toHaveProperty('disclaimer');
+  });
+});

package/tests/tools/search-safety-rules.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createTestDatabase } from '../helpers/seed-db.js';
+import { handleSearchSafetyRules } from '../../src/tools/search-safety-rules.js';
+import type { Database } from '../../src/db.js';
+
+let db: Database;
+
+beforeAll(() => {
+  db = createTestDatabase();
+});
+
+afterAll(() => {
+  db.close();
+});
+
+describe('search_safety_rules tool', () => {
+  it('returns results for a valid query', () => {
+    const result = handleSearchSafetyRules(db, { query: 'Traktor' });
+    expect(result).toHaveProperty('results_count');
+    expect((result as any).results_count).toBeGreaterThan(0);
+    expect((result as any).results).toBeInstanceOf(Array);
+  });
+
+  it('returns jurisdiction in response', () => {
+    const result = handleSearchSafetyRules(db, { query: 'Traktor' });
+    expect((result as any).jurisdiction).toBe('CH');
+  });
+
+  it('returns results with expected fields', () => {
+    const result = handleSearchSafetyRules(db, { query: 'ROPS' });
+    if ((result as any).results_count > 0) {
+      const first = (result as any).results[0];
+      expect(first).toHaveProperty('title');
+      expect(first).toHaveProperty('body');
+      expect(first).toHaveProperty('area');
+      expect(first).toHaveProperty('relevance_rank');
+    }
+  });
+
+  it('filters by topic when provided', () => {
+    const result = handleSearchSafetyRules(db, { query: 'Sicherheit', topic: 'maschinen' });
+    if ((result as any).results_count > 0) {
+      for (const r of (result as any).results) {
+        expect(r.area.toLowerCase()).toBe('maschinen');
+      }
+    }
+  });
+
+  it('respects limit parameter', () => {
+    const result = handleSearchSafetyRules(db, { query: 'Sicherheit', limit: 1 });
+    expect((result as any).results.length).toBeLessThanOrEqual(1);
+  });
+
+  it('caps limit at 50', () => {
+    const result = handleSearchSafetyRules(db, { query: 'Sicherheit', limit: 100 });
+    expect((result as any).results.length).toBeLessThanOrEqual(50);
+  });
+
+  it('rejects unsupported jurisdiction', () => {
+    const result = handleSearchSafetyRules(db, { query: 'test', jurisdiction: 'DE' });
+    expect(result).toHaveProperty('error', 'jurisdiction_not_supported');
+  });
+
+  it('includes _meta in successful response', () => {
+    const result = handleSearchSafetyRules(db, { query: 'Traktor' });
+    expect((result as any)._meta).toBeDefined();
+    expect((result as any)._meta).toHaveProperty('disclaimer');
+  });
+
+  it('returns empty results for non-matching query', () => {
+    const result = handleSearchSafetyRules(db, { query: 'xyznonexistent' });
+    expect((result as any).results_count).toBe(0);
+    expect((result as any).results).toEqual([]);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "scripts"]
+}

package/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    globals: false,
+    testTimeout: 10000,
+  },
+});