@ansvar/ch-organic-regen-mcp 0.1.0

package/src/tools/search-organic-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 handleSearchOrganicRules(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.topic.toLowerCase().includes(args.topic!.toLowerCase()));
+  }
+
+  return {
+    query: args.query,
+    jurisdiction: jv.jurisdiction,
+    results_count: results.length,
+    results: results.map(r => ({
+      title: r.title,
+      body: r.body,
+      topic: r.topic,
+      relevance_rank: r.rank,
+    })),
+    _meta: buildMeta(),
+  };
+}

package/tests/db.test.ts

@@ -0,0 +1,96 @@
+import { describe, test, expect, beforeAll, afterAll } from 'vitest';
+import { createDatabase, type Database } from '../src/db.js';
+import { existsSync, unlinkSync } from 'fs';
+
+const TEST_DB = 'tests/test-database.db';
+
+describe('database layer', () => {
+  let db: Database;
+
+  beforeAll(() => {
+    db = createDatabase(TEST_DB);
+  });
+
+  afterAll(() => {
+    db.close();
+    if (existsSync(TEST_DB)) unlinkSync(TEST_DB);
+  });
+
+  test('creates database with db_metadata table', () => {
+    const row = db.get<{ value: string }>(
+      'SELECT value FROM db_metadata WHERE key = ?',
+      ['schema_version']
+    );
+    expect(row?.value).toBe('1.0');
+  });
+
+  test('creates organic_standards table', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='organic_standards'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('creates conversion_requirements table', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='conversion_requirements'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('creates approved_inputs table', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='approved_inputs'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('creates organic_subsidies table', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='organic_subsidies'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('creates soil_health table', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='soil_health'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('creates certification_guidance table', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='certification_guidance'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('FTS5 search_index exists', () => {
+    const result = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='search_index'"
+    );
+    expect(result).toHaveLength(1);
+  });
+
+  test('journal mode is DELETE', () => {
+    const row = db.get<{ journal_mode: string }>('PRAGMA journal_mode');
+    expect(row?.journal_mode).toBe('delete');
+  });
+
+  test('mcp_name metadata is set', () => {
+    const row = db.get<{ value: string }>(
+      'SELECT value FROM db_metadata WHERE key = ?',
+      ['mcp_name']
+    );
+    expect(row?.value).toContain('Organic');
+  });
+
+  test('jurisdiction metadata is CH', () => {
+    const row = db.get<{ value: string }>(
+      'SELECT value FROM db_metadata WHERE key = ?',
+      ['jurisdiction']
+    );
+    expect(row?.value).toBe('CH');
+  });
+});

package/tests/helpers/seed-db.ts

@@ -0,0 +1,145 @@
+import { createDatabase, type Database } from '../../src/db.js';
+
+export function createSeededDatabase(dbPath: string): Database {
+  const db = createDatabase(dbPath);
+
+  // Organic standards — Knospe, Bio-Verordnung, Demeter
+  db.run(
+    `INSERT INTO organic_standards (id, production_type, standard, rule, description, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [1, 'futtermittel', 'knospe', '100% Bio-Futter, davon mindestens 90% Knospe-Qualitaet',
+     'Knospe-Betriebe muessen 100% biologisches Futter einsetzen, davon mindestens 90% aus Knospe-zertifizierter Produktion.', 'CH']
+  );
+  db.run(
+    `INSERT INTO organic_standards (id, production_type, standard, rule, description, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [2, 'futtermittel', 'bio_verordnung', 'Mindestens 95% Bio-Futter',
+     'Gemaess Bio-Verordnung SR 910.18 muessen mindestens 95% des Futters aus biologischer Produktion stammen.', 'CH']
+  );
+  db.run(
+    `INSERT INTO organic_standards (id, production_type, standard, rule, description, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [3, 'tierhaltung', 'demeter', 'Biodynamische Tierhaltung mit Horntraegern',
+     'Demeter verlangt horntragende Rinder und biodynamische Futterpraeparate (Praeparate 500-508).', 'CH']
+  );
+
+  // Conversion requirements
+  db.run(
+    `INSERT INTO conversion_requirements (id, farm_type, current_system, timeline_years, requirements, support_measures, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [1, 'ackerbau', 'konventionell', 2,
+     'Gesamtbetriebliche Umstellung, Pflanzenschutz nach FiBL-Liste, Fruchtfolge mindestens 4 Kulturen',
+     'FiBL Umstellungsberatung, kantonale Beratung, AGRIDEA Merkblaetter', 'CH']
+  );
+  db.run(
+    `INSERT INTO conversion_requirements (id, farm_type, current_system, timeline_years, requirements, support_measures, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [2, 'milchwirtschaft', 'oeln', 1,
+     'Futter 100% Bio (90% Knospe), Weidepflicht, Laufstall oder Auslauf taeglich',
+     'Bio Suisse Beratung, kantonale Fachstelle, Umstellungsbeitrag BLW', 'CH']
+  );
+
+  // Approved inputs
+  db.run(
+    `INSERT INTO approved_inputs (id, input_type, product_name, description, restrictions, source, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [1, 'duenger', 'Kompost (Knospe-konform)',
+     'Gruengutkompost und Hofduenger-Kompost fuer Naehrstoffversorgung und Humusaufbau',
+     'Maximal 2.5 DGVE/ha, keine Klaerschlammbeimischung',
+     'FiBL Betriebsmittelliste', 'CH']
+  );
+  db.run(
+    `INSERT INTO approved_inputs (id, input_type, product_name, description, restrictions, source, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [2, 'pflanzenschutz', 'Kupferpraeparat',
+     'Kupferhydroxid zur Bekaempfung von Pilzkrankheiten im Rebbau und Obstbau',
+     'Maximal 4 kg Reinkupfer/ha/Jahr (Knospe), 6 kg/ha (Bio-Verordnung)',
+     'FiBL Betriebsmittelliste', 'CH']
+  );
+
+  // Organic subsidies
+  db.run(
+    `INSERT INTO organic_subsidies (id, subsidy_type, zone, rate_chf_ha, conditions, stacking_rules, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [1, 'bio_beitrag', 'talzone', 1600,
+     'Gesamtbetriebliche Bioproduktion, Kontrolle durch anerkannte Inspektionsstelle',
+     'Kumulierbar mit Extenso, BFF-Beitraegen, Tierwohl-Beitraegen', 'CH']
+  );
+  db.run(
+    `INSERT INTO organic_subsidies (id, subsidy_type, zone, rate_chf_ha, conditions, stacking_rules, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [2, 'bio_beitrag', 'bergzone_ii', 1100,
+     'Gesamtbetriebliche Bioproduktion, Kontrolle durch anerkannte Inspektionsstelle',
+     'Kumulierbar mit Extenso, BFF-Beitraegen, Tierwohl-Beitraegen, Soemmerungsbeitrag', 'CH']
+  );
+
+  // Soil health guidance
+  db.run(
+    `INSERT INTO soil_health (id, topic, guidance, technique, benefits, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [1, 'kompost',
+     'Qualitaetskompost foerdert Bodenstruktur, Wasserhaltefaehigkeit und Bodenbiologie',
+     'Flaechen- oder Reihenkompostierung, 3-6 Monate Rottedauer, C/N-Verhaeltnis 25-30:1',
+     'Humusaufbau, Naehrstoffversorgung, Krankheitsunterdrueckung', 'CH']
+  );
+  db.run(
+    `INSERT INTO soil_health (id, topic, guidance, technique, benefits, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    [2, 'gruenduengung',
+     'Gruenduengung mit Leguminosen fixiert Stickstoff und schuetzt den Boden vor Erosion',
+     'Alexandrinerklee, Inkarnatklee, Luzerne oder Mischungen nach FiBL-Empfehlung',
+     'Stickstoff-Fixierung, Erosionsschutz, Bodenstrukturverbesserung', 'CH']
+  );
+
+  // Certification guidance
+  db.run(
+    `INSERT INTO certification_guidance (id, step, description, inspector, frequency, cost_notes, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [1, 'anmeldung',
+     'Anmeldung bei Bio Suisse und einer anerkannten Inspektionsstelle (bio.inspecta oder Bio Test Agro)',
+     'bio.inspecta / Bio Test Agro',
+     'einmalig',
+     'Anmeldegebuehr ca. CHF 200-400', 'CH']
+  );
+  db.run(
+    `INSERT INTO certification_guidance (id, step, description, inspector, frequency, cost_notes, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [2, 'kontrolle',
+     'Jaehrliche Betriebskontrolle mit unangekuendigten Stichprobenkontrollen',
+     'bio.inspecta / Bio Test Agro',
+     'jaehrlich',
+     'Kontrollkosten ca. CHF 500-1200 je nach Betriebsgroesse', 'CH']
+  );
+
+  // FTS5 search index
+  db.run(
+    `INSERT INTO search_index (title, body, topic, jurisdiction) VALUES (?, ?, ?, ?)`,
+    ['Knospe Futtermittel-Anforderungen',
+     'Knospe-Betriebe muessen 100% biologisches Futter einsetzen, davon mindestens 90% aus Knospe-zertifizierter Produktion. Maximal 10% EU-Bio.',
+     'futtermittel', 'CH']
+  );
+  db.run(
+    `INSERT INTO search_index (title, body, topic, jurisdiction) VALUES (?, ?, ?, ?)`,
+    ['Umstellung Ackerbau auf Bio',
+     'Umstellungsdauer 2 Jahre fuer Ackerbau bei konventioneller Bewirtschaftung. Pflanzenschutz nach FiBL-Betriebsmittelliste. Fruchtfolge mindestens 4 Kulturen.',
+     'umstellung', 'CH']
+  );
+  db.run(
+    `INSERT INTO search_index (title, body, topic, jurisdiction) VALUES (?, ?, ?, ?)`,
+    ['Kompost fuer Bodenfruchtbarkeit',
+     'Qualitaetskompost foerdert Bodenstruktur und Humusaufbau. Flaechen- oder Reihenkompostierung mit C/N-Verhaeltnis 25-30:1.',
+     'bodenfruchtbarkeit', 'CH']
+  );
+
+  // db_metadata for freshness
+  db.run(
+    `INSERT OR REPLACE INTO db_metadata (key, value) VALUES ('last_ingest', ?)`,
+    [new Date().toISOString().split('T')[0]]
+  );
+  db.run(
+    `INSERT OR REPLACE INTO db_metadata (key, value) VALUES ('build_date', ?)`,
+    [new Date().toISOString().split('T')[0]]
+  );
+
+  return db;
+}

package/tests/jurisdiction.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect } from 'vitest';
+import { validateJurisdiction, SUPPORTED_JURISDICTIONS } from '../src/jurisdiction.js';
+
+describe('jurisdiction validation', () => {
+  test('accepts CH', () => {
+    const result = validateJurisdiction('CH');
+    expect(result).toEqual({ valid: true, jurisdiction: 'CH' });
+  });
+
+  test('defaults to CH when undefined', () => {
+    const result = validateJurisdiction(undefined);
+    expect(result).toEqual({ valid: true, jurisdiction: 'CH' });
+  });
+
+  test('rejects unsupported jurisdiction', () => {
+    const result = validateJurisdiction('DE');
+    expect(result).toEqual({
+      valid: false,
+      error: {
+        error: 'jurisdiction_not_supported',
+        supported: ['CH'],
+        message: 'This server currently covers Switzerland. More jurisdictions are planned.',
+      },
+    });
+  });
+
+  test('normalises lowercase input', () => {
+    const result = validateJurisdiction('ch');
+    expect(result).toEqual({ valid: true, jurisdiction: 'CH' });
+  });
+
+  test('SUPPORTED_JURISDICTIONS contains CH', () => {
+    expect(SUPPORTED_JURISDICTIONS).toContain('CH');
+  });
+});

package/tests/tools/about.test.ts

@@ -0,0 +1,22 @@
+import { describe, test, expect } from 'vitest';
+import { handleAbout } from '../../src/tools/about.js';
+
+describe('about tool', () => {
+  test('returns server metadata', () => {
+    const result = handleAbout();
+    expect(result.name).toContain('Organic');
+    expect(result.description).toContain('Bio Suisse');
+    expect(result.jurisdiction).toEqual(['CH']);
+    expect(result.tools_count).toBe(10);
+    expect(result.links).toHaveProperty('homepage');
+    expect(result.links).toHaveProperty('repository');
+    expect(result._meta).toHaveProperty('disclaimer');
+  });
+
+  test('lists data sources', () => {
+    const result = handleAbout();
+    expect(result.data_sources).toContain('Bio Suisse Richtlinien (Knospe)');
+    expect(result.data_sources).toContain('FiBL Betriebsmittelliste');
+    expect(result.data_sources).toContain('Demeter Schweiz Richtlinien');
+  });
+});

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

@@ -0,0 +1,57 @@
+import { describe, test, expect, beforeAll, afterAll } from 'vitest';
+import { handleCheckFreshness } from '../../src/tools/check-freshness.js';
+import { createDatabase, type Database } from '../../src/db.js';
+import { existsSync, unlinkSync } from 'fs';
+
+const TEST_DB = 'tests/test-check-freshness.db';
+
+describe('check_data_freshness tool', () => {
+  let db: Database;
+
+  beforeAll(() => {
+    db = createDatabase(TEST_DB);
+  });
+
+  afterAll(() => {
+    db.close();
+    if (existsSync(TEST_DB)) unlinkSync(TEST_DB);
+  });
+
+  test('returns unknown when no ingest date', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.status).toBe('unknown');
+    expect(result.days_since_ingest).toBeNull();
+  });
+
+  test('returns fresh when recently ingested', () => {
+    const today = new Date().toISOString().split('T')[0];
+    db.run("INSERT OR REPLACE INTO db_metadata (key, value) VALUES ('last_ingest', ?)", [today]);
+
+    const result = handleCheckFreshness(db);
+    expect(result.status).toBe('fresh');
+    expect(result.days_since_ingest).toBeLessThanOrEqual(1);
+  });
+
+  test('returns stale when old ingest', () => {
+    db.run("INSERT OR REPLACE INTO db_metadata (key, value) VALUES ('last_ingest', '2025-01-01')", []);
+
+    const result = handleCheckFreshness(db);
+    expect(result.status).toBe('stale');
+    expect(result.days_since_ingest).toBeGreaterThan(90);
+  });
+
+  test('includes refresh command', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.refresh_command).toContain('gh workflow run');
+  });
+
+  test('includes schema_version', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.schema_version).toBe('1.0');
+  });
+
+  test('staleness threshold is 90 days', () => {
+    const result = handleCheckFreshness(db);
+    expect(result.staleness_threshold_days).toBe(90);
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, test, expect, beforeAll, afterAll } from 'vitest';
+import { handleListSources } from '../../src/tools/list-sources.js';
+import { createDatabase, type Database } from '../../src/db.js';
+import { existsSync, unlinkSync } from 'fs';
+
+const TEST_DB = 'tests/test-list-sources.db';
+
+describe('list_sources tool', () => {
+  let db: Database;
+
+  beforeAll(() => {
+    db = createDatabase(TEST_DB);
+  });
+
+  afterAll(() => {
+    db.close();
+    if (existsSync(TEST_DB)) unlinkSync(TEST_DB);
+  });
+
+  test('returns 5 data sources', () => {
+    const result = handleListSources(db);
+    expect(result.sources).toHaveLength(5);
+  });
+
+  test('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('license');
+      expect(source).toHaveProperty('update_frequency');
+      expect(source).toHaveProperty('coverage');
+    }
+  });
+
+  test('includes Bio Suisse as a source', () => {
+    const result = handleListSources(db);
+    const bioSuisse = result.sources.find(s => s.name.includes('Bio Suisse'));
+    expect(bioSuisse).toBeDefined();
+    expect(bioSuisse!.authority).toBe('Bio Suisse');
+  });
+
+  test('includes FiBL as a source', () => {
+    const result = handleListSources(db);
+    const fibl = result.sources.find(s => s.name.includes('FiBL'));
+    expect(fibl).toBeDefined();
+    expect(fibl!.authority).toContain('FiBL');
+  });
+
+  test('includes _meta', () => {
+    const result = handleListSources(db);
+    expect(result._meta).toHaveProperty('disclaimer');
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, test, expect, beforeAll, afterAll } from 'vitest';
+import { handleSearchOrganicRules } from '../../src/tools/search-organic-rules.js';
+import { createSeededDatabase } from '../helpers/seed-db.js';
+import type { Database } from '../../src/db.js';
+import { existsSync, unlinkSync } from 'fs';
+
+const TEST_DB = 'tests/test-search-organic.db';
+
+describe('search_organic_rules tool', () => {
+  let db: Database;
+
+  beforeAll(() => {
+    db = createSeededDatabase(TEST_DB);
+  });
+
+  afterAll(() => {
+    db.close();
+    if (existsSync(TEST_DB)) unlinkSync(TEST_DB);
+  });
+
+  test('returns results for Knospe query', () => {
+    const result = handleSearchOrganicRules(db, { query: 'Knospe Futter' });
+    expect(result).toHaveProperty('results_count');
+    expect((result as { results_count: number }).results_count).toBeGreaterThan(0);
+  });
+
+  test('returns results for Umstellung query', () => {
+    const result = handleSearchOrganicRules(db, { query: 'Umstellung' });
+    expect(result).toHaveProperty('results_count');
+    expect((result as { results_count: number }).results_count).toBeGreaterThan(0);
+  });
+
+  test('respects topic filter', () => {
+    const result = handleSearchOrganicRules(db, { query: 'Knospe', topic: 'futtermittel' });
+    const typed = result as { results: { topic: string }[] };
+    for (const r of typed.results) {
+      expect(r.topic.toLowerCase()).toContain('futtermittel');
+    }
+  });
+
+  test('respects limit parameter', () => {
+    const result = handleSearchOrganicRules(db, { query: 'Bio', limit: 1 });
+    const typed = result as { results: unknown[] };
+    expect(typed.results.length).toBeLessThanOrEqual(1);
+  });
+
+  test('rejects unsupported jurisdiction', () => {
+    const result = handleSearchOrganicRules(db, { query: 'Bio', jurisdiction: 'FR' });
+    expect(result).toHaveProperty('error', 'jurisdiction_not_supported');
+  });
+
+  test('includes _meta in response', () => {
+    const result = handleSearchOrganicRules(db, { query: 'Kompost' });
+    expect(result).toHaveProperty('_meta');
+  });
+});

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"]
+}