@ansvar/ch-livestock-mcp 0.1.0

package/src/tools/list-sources.ts

@@ -0,0 +1,65 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface Source {
+  name: string;
+  authority: string;
+  official_url: string;
+  retrieval_method: string;
+  update_frequency: string;
+  license: string;
+  coverage: string;
+  last_retrieved?: string;
+}
+
+export function handleListSources(db: Database): { sources: Source[]; _meta: ReturnType<typeof buildMeta> } {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+
+  const sources: Source[] = [
+    {
+      name: 'Tierschutzverordnung (TSchV, SR 455.1)',
+      authority: 'Bundesamt fuer Lebensmittelsicherheit und Veterinaerwesen (BLV)',
+      official_url: 'https://www.fedlex.admin.ch/eli/cc/2008/416/de',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'periodic (amended as needed)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Minimum welfare standards per species, space requirements, housing, transport, slaughter',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Direktzahlungsverordnung (DZV) — RAUS/BTS-Programme',
+      authority: 'Bundesamt fuer Landwirtschaft (BLW)',
+      official_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/direktzahlungen/produktionssystembeitraege/tierwohlbeitraege.html',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual (with DZV updates)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'RAUS outdoor access requirements, BTS housing standards, payment rates per GVE',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Tierverkehrsdatenbank (TVD)',
+      authority: 'Identitas AG / BLV',
+      official_url: 'https://www.identitas.ch/tvd',
+      retrieval_method: 'PUBLIC_DOCS',
+      update_frequency: 'continuous (registration rules updated periodically)',
+      license: 'Public regulatory information',
+      coverage: 'Animal registration, ear tags, movement reporting, species coverage',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Zuchtorganisationen (Braunvieh Schweiz, swissherdbook, Mutterkuh Schweiz, Suisseporcs)',
+      authority: 'Various breed associations',
+      official_url: 'https://www.braunvieh.ch',
+      retrieval_method: 'PUBLIC_DOCS',
+      update_frequency: 'annual',
+      license: 'Public breed information',
+      coverage: 'Swiss cattle, pig, sheep, goat, and horse breeds — characteristics, purpose, regional distribution',
+      last_retrieved: lastIngest?.value,
+    },
+  ];
+
+  return {
+    sources,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/search-animal-health.ts

@@ -0,0 +1,48 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface HealthSearchArgs {
+  query: string;
+  species?: string;
+  jurisdiction?: string;
+}
+
+export function handleSearchAnimalHealth(db: Database, args: HealthSearchArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = 'SELECT * FROM animal_health WHERE jurisdiction = ?';
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.species) {
+    sql += ' AND LOWER(species) = LOWER(?)';
+    params.push(args.species);
+  }
+
+  const all = db.all<{
+    id: number; species: string; condition: string; symptoms: string;
+    prevention: string; regulatory_status: string; details: string;
+  }>(sql, params);
+
+  // Filter by query terms (case-insensitive substring match across all text fields)
+  const queryLower = args.query.toLowerCase();
+  const terms = queryLower.split(/\s+/).filter(t => t.length > 1);
+
+  const filtered = all.filter(row => {
+    const text = [row.condition, row.symptoms, row.prevention, row.details, row.regulatory_status]
+      .filter(Boolean)
+      .join(' ')
+      .toLowerCase();
+    return terms.some(t => text.includes(t));
+  });
+
+  return {
+    query: args.query,
+    species_filter: args.species ?? null,
+    jurisdiction: jv.jurisdiction,
+    results_count: filtered.length,
+    results: filtered,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/search-livestock-guidance.ts

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

package/tests/db.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { createTestDatabase } from './helpers/seed-db.js';
+import { ftsSearch, tieredFtsSearch, type Database } from '../src/db.js';
+
+let db: Database;
+
+afterEach(() => {
+  db?.close();
+});
+
+describe('createDatabase', () => {
+  it('creates all tables and metadata', () => {
+    db = createTestDatabase();
+    const tables = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    );
+    const tableNames = tables.map(t => t.name).sort();
+    expect(tableNames).toContain('welfare_standards');
+    expect(tableNames).toContain('stocking_densities');
+    expect(tableNames).toContain('housing_requirements');
+    expect(tableNames).toContain('movement_rules');
+    expect(tableNames).toContain('breeds');
+    expect(tableNames).toContain('feed_requirements');
+    expect(tableNames).toContain('animal_health');
+    expect(tableNames).toContain('db_metadata');
+  });
+
+  it('has search_index FTS table', () => {
+    db = createTestDatabase();
+    const fts = db.all<{ name: string }>(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name='search_index'"
+    );
+    expect(fts.length).toBe(1);
+  });
+
+  it('seeds db_metadata correctly', () => {
+    db = createTestDatabase();
+    const meta = db.get<{ value: string }>(
+      'SELECT value FROM db_metadata WHERE key = ?',
+      ['schema_version']
+    );
+    expect(meta?.value).toBe('1.0');
+  });
+});
+
+describe('ftsSearch', () => {
+  it('returns results for a matching query', () => {
+    db = createTestDatabase();
+    const results = ftsSearch(db, 'Milchkuh Laufstall');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].title).toContain('Milchkuh');
+  });
+
+  it('filters by species', () => {
+    db = createTestDatabase();
+    const results = ftsSearch(db, 'Auslauf', 20, 'Schweine');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].species).toBe('Schweine');
+  });
+
+  it('returns empty array for non-matching query', () => {
+    db = createTestDatabase();
+    const results = ftsSearch(db, 'xyznonexistent');
+    expect(results).toEqual([]);
+  });
+
+  it('respects limit parameter', () => {
+    db = createTestDatabase();
+    const results = ftsSearch(db, 'Milchkuh', 1);
+    expect(results.length).toBeLessThanOrEqual(1);
+  });
+});
+
+describe('tieredFtsSearch', () => {
+  it('returns tier information with results', () => {
+    db = createTestDatabase();
+    const { tier, results } = tieredFtsSearch(
+      db, 'search_index',
+      ['title', 'body', 'species', 'category', 'jurisdiction'],
+      'Milchkuh', 20
+    );
+    expect(results.length).toBeGreaterThan(0);
+    expect(['phrase', 'and', 'prefix', 'stemmed', 'or', 'like']).toContain(tier);
+  });
+
+  it('returns empty for blank query', () => {
+    db = createTestDatabase();
+    const { tier, results } = tieredFtsSearch(
+      db, 'search_index',
+      ['title', 'body', 'species', 'category', 'jurisdiction'],
+      '', 20
+    );
+    expect(tier).toBe('empty');
+    expect(results).toEqual([]);
+  });
+});

package/tests/helpers/seed-db.ts

@@ -0,0 +1,97 @@
+import { createDatabase, type Database } from '../../src/db.js';
+import { join } from 'path';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
+
+/**
+ * Create a temporary seeded database for tests.
+ * Schema matches src/db.ts initSchema exactly.
+ */
+export function createTestDatabase(): Database {
+  const dir = mkdtempSync(join(tmpdir(), 'ch-livestock-test-'));
+  const dbPath = join(dir, 'test.db');
+  const db = createDatabase(dbPath);
+
+  // welfare_standards: 2 records
+  db.run(
+    `INSERT INTO welfare_standards (species, production_system, requirement, min_space_m2, details, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ['Rinder', 'TSchV-Minimum', 'Liegeflaeche Milchkuh', 4.5, 'Mindestens 4.5 m2 pro Milchkuh im Laufstall gemaess TSchV Anhang 1', 'DE', 'CH']
+  );
+  db.run(
+    `INSERT INTO welfare_standards (species, production_system, requirement, min_space_m2, details, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ['Schweine', 'RAUS', 'Auslauf Mastschwein', 1.3, 'Mastschweine muessen taeglich Zugang zum Auslauf haben, mindestens 1.3 m2', 'DE', 'CH']
+  );
+
+  // stocking_densities: 2 records
+  db.run(
+    `INSERT INTO stocking_densities (species, age_class, housing_type, animals_per_m2, regulatory_minimum, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ['Rinder', 'Milchkuh', 'Laufstall', 0.22, 'TSchV Anhang 1 Tabelle 1', 'DE', 'CH']
+  );
+  db.run(
+    `INSERT INTO stocking_densities (species, age_class, housing_type, animals_per_m2, regulatory_minimum, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    ['Gefluegel', 'Legehenne', 'Voliere', 7.0, 'TSchV Anhang 1 Tabelle 9', 'DE', 'CH']
+  );
+
+  // housing_requirements: 1 record
+  db.run(
+    `INSERT INTO housing_requirements (species, age_class, system, space, ventilation, flooring, temperature, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ['Rinder', 'Milchkuh', 'Laufstall', '4.5 m2 Liegeflaeche', 'Natuerliche Belueftung oder Zwangsbelueftung', 'Rutschfester Belag, perforiert max 3%', '0-25 C', 'DE', 'CH']
+  );
+
+  // movement_rules: 1 record
+  db.run(
+    `INSERT INTO movement_rules (species, rule_type, description, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?)`,
+    ['Rinder', 'TVD', 'Alle Rinder muessen innerhalb von 3 Tagen nach Geburt bei der TVD gemeldet werden. Ohrmarken sind Pflicht.', 'DE', 'CH']
+  );
+
+  // breeds: 1 record
+  db.run(
+    `INSERT INTO breeds (species, name, purpose, notes, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+    ['Rinder', 'Braunvieh', 'Zweinutzung (Milch und Fleisch)', 'Traditionsrasse der Schweizer Alpen, hohe Milchleistung bei guter Fleischqualitaet', 'DE', 'CH']
+  );
+
+  // feed_requirements: 1 record
+  db.run(
+    `INSERT INTO feed_requirements (species, age_class, production_stage, feed_type, quantity_kg_day, energy_mj, protein_g, notes, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    ['Rinder', 'Milchkuh', 'Laktation', 'Grundfutter + Kraftfutter', 22.0, 115.0, 2800.0, 'Bei 30 kg Milchleistung, GMF-konform: mind. 75% Grundfutter', 'DE', 'CH']
+  );
+
+  // animal_health: 1 record
+  db.run(
+    `INSERT INTO animal_health (species, condition, symptoms, prevention, regulatory_status, details, language, jurisdiction)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+    ['Rinder', 'BVD (Bovine Virusdiarrhoe)', 'Durchfall, Fieber, Schleimhautlaesionen, Fruchtbarkeitsstoerungen', 'Impfung, PI-Tier-Erkennung und Merzung', 'Meldepflichtige Tierseuche (TSV Art. 5)', 'BVD-Ausrottungsprogramm seit 2008, PI-Tiere muessen innert 10 Tagen entfernt werden', 'DE', 'CH']
+  );
+
+  // search_index (FTS5): 2 entries matching CH jurisdiction
+  db.run(
+    `INSERT INTO search_index (title, body, species, category, jurisdiction)
+     VALUES (?, ?, ?, ?, ?)`,
+    ['Liegeflaeche Milchkuh Laufstall', 'Mindestens 4.5 m2 Liegeflaeche pro Milchkuh im Laufstall gemaess TSchV Anhang 1', 'Rinder', 'welfare', 'CH']
+  );
+  db.run(
+    `INSERT INTO search_index (title, body, species, category, jurisdiction)
+     VALUES (?, ?, ?, ?, ?)`,
+    ['Auslauf Mastschwein RAUS', 'Mastschweine muessen taeglich Zugang zum Auslauf haben, mindestens 1.3 m2 pro Tier', 'Schweine', 'welfare', 'CH']
+  );
+
+  // db_metadata: ingest date for freshness tests
+  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,41 @@
+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('exports SUPPORTED_JURISDICTIONS with CH', () => {
+    expect(SUPPORTED_JURISDICTIONS).toContain('CH');
+  });
+});

package/tests/tools/about.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { handleAbout } from '../../src/tools/about.js';
+
+describe('about tool', () => {
+  it('returns server metadata', () => {
+    const result = handleAbout();
+    expect(result.name).toBe('Switzerland Livestock MCP');
+    expect(result.version).toBe('0.1.0');
+    expect(result.jurisdiction).toContain('CH');
+    expect(result.tools_count).toBe(11);
+  });
+
+  it('includes data_sources', () => {
+    const result = handleAbout();
+    expect(result.data_sources.length).toBeGreaterThan(0);
+    expect(result.data_sources.some((s: string) => s.includes('TSchV'))).toBe(true);
+  });
+
+  it('includes links', () => {
+    const result = handleAbout();
+    expect(result.links.homepage).toContain('ansvar.eu');
+    expect(result.links.repository).toContain('ch-livestock-mcp');
+    expect(result.links.mcp_network).toContain('ansvar.ai');
+  });
+
+  it('includes _meta with disclaimer', () => {
+    const result = handleAbout();
+    expect(result._meta).toBeDefined();
+    expect(result._meta.disclaimer).toBeTruthy();
+    expect(result._meta.server).toBe('ch-livestock-mcp');
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, it, expect, afterEach } 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;
+
+afterEach(() => {
+  db?.close();
+});
+
+describe('check_data_freshness tool', () => {
+  it('returns fresh status for recent data', () => {
+    db = createTestDatabase();
+    const result = handleCheckFreshness(db);
+    expect(result.status).toBe('fresh');
+    expect(result.last_ingest).toBe('2026-04-05');
+    expect(result.days_since_ingest).toBeTypeOf('number');
+  });
+
+  it('includes schema_version', () => {
+    db = createTestDatabase();
+    const result = handleCheckFreshness(db);
+    expect(result.schema_version).toBe('1.0');
+  });
+
+  it('includes refresh_command', () => {
+    db = createTestDatabase();
+    const result = handleCheckFreshness(db);
+    expect(result.refresh_command).toContain('ingest.yml');
+    expect(result.refresh_command).toContain('ch-livestock-mcp');
+  });
+
+  it('includes staleness threshold', () => {
+    db = createTestDatabase();
+    const result = handleCheckFreshness(db);
+    expect(result.staleness_threshold_days).toBe(90);
+  });
+
+  it('includes _meta', () => {
+    db = createTestDatabase();
+    const result = handleCheckFreshness(db);
+    expect(result._meta).toBeDefined();
+    expect(result._meta.disclaimer).toBeTruthy();
+  });
+
+  it('returns unknown for missing ingest date', () => {
+    db = createTestDatabase();
+    db.run("DELETE FROM db_metadata WHERE key = 'last_ingest'");
+    const result = handleCheckFreshness(db);
+    expect(result.status).toBe('unknown');
+    expect(result.last_ingest).toBeNull();
+    expect(result.days_since_ingest).toBeNull();
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, it, expect, afterEach } 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;
+
+afterEach(() => {
+  db?.close();
+});
+
+describe('list_sources tool', () => {
+  it('returns 4 data sources', () => {
+    db = createTestDatabase();
+    const result = handleListSources(db);
+    expect(result.sources.length).toBe(4);
+  });
+
+  it('includes TSchV source', () => {
+    db = createTestDatabase();
+    const result = handleListSources(db);
+    const tschv = result.sources.find(s => s.name.includes('TSchV'));
+    expect(tschv).toBeDefined();
+    expect(tschv!.authority).toContain('BLV');
+    expect(tschv!.official_url).toContain('fedlex.admin.ch');
+  });
+
+  it('includes DZV RAUS/BTS source', () => {
+    db = createTestDatabase();
+    const result = handleListSources(db);
+    const dzv = result.sources.find(s => s.name.includes('DZV'));
+    expect(dzv).toBeDefined();
+    expect(dzv!.authority).toContain('BLW');
+  });
+
+  it('includes TVD source', () => {
+    db = createTestDatabase();
+    const result = handleListSources(db);
+    const tvd = result.sources.find(s => s.name.includes('TVD'));
+    expect(tvd).toBeDefined();
+    expect(tvd!.authority).toContain('Identitas');
+  });
+
+  it('includes last_retrieved from db_metadata', () => {
+    db = createTestDatabase();
+    const result = handleListSources(db);
+    expect(result.sources[0].last_retrieved).toBe('2026-04-05');
+  });
+
+  it('includes _meta', () => {
+    db = createTestDatabase();
+    const result = handleListSources(db);
+    expect(result._meta).toBeDefined();
+    expect(result._meta.disclaimer).toBeTruthy();
+  });
+});

package/tests/tools/search-livestock-guidance.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { createTestDatabase } from '../helpers/seed-db.js';
+import { handleSearchLivestockGuidance } from '../../src/tools/search-livestock-guidance.js';
+import type { Database } from '../../src/db.js';
+
+let db: Database;
+
+afterEach(() => {
+  db?.close();
+});
+
+describe('search_livestock_guidance tool', () => {
+  it('returns results for a matching query', () => {
+    db = createTestDatabase();
+    const result = handleSearchLivestockGuidance(db, { query: 'Milchkuh' });
+    expect(result).toHaveProperty('results');
+    expect(result).toHaveProperty('results_count');
+    if ('results' in result) {
+      expect((result as { results_count: number }).results_count).toBeGreaterThan(0);
+    }
+  });
+
+  it('filters by species', () => {
+    db = createTestDatabase();
+    const result = handleSearchLivestockGuidance(db, { query: 'Auslauf', species: 'Schweine' });
+    if ('results' in result && Array.isArray((result as Record<string, unknown>).results)) {
+      const results = (result as { results: Array<{ species: string }> }).results;
+      results.forEach(r => {
+        expect(r.species).toBe('Schweine');
+      });
+    }
+  });
+
+  it('respects limit', () => {
+    db = createTestDatabase();
+    const result = handleSearchLivestockGuidance(db, { query: 'Milchkuh', limit: 1 });
+    if ('results' in result && Array.isArray((result as Record<string, unknown>).results)) {
+      expect((result as { results: unknown[] }).results.length).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it('caps limit at 50', () => {
+    db = createTestDatabase();
+    const result = handleSearchLivestockGuidance(db, { query: 'Milchkuh', limit: 100 });
+    // Should not error -- limit is capped internally
+    expect(result).toBeDefined();
+  });
+
+  it('rejects unsupported jurisdiction', () => {
+    db = createTestDatabase();
+    const result = handleSearchLivestockGuidance(db, { query: 'test', jurisdiction: 'DE' });
+    expect(result).toHaveProperty('error');
+    expect((result as { error: string }).error).toBe('jurisdiction_not_supported');
+  });
+
+  it('includes _meta in response', () => {
+    db = createTestDatabase();
+    const result = handleSearchLivestockGuidance(db, { query: 'Milchkuh' });
+    if ('_meta' in result) {
+      expect((result as { _meta: { disclaimer: string } })._meta.disclaimer).toBeTruthy();
+    }
+  });
+});

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