@ansvar/ch-farm-grants-mcp 0.1.0

package/src/server.ts

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { createDatabase } from './db.js';
+import { handleAbout } from './tools/about.js';
+import { handleListSources } from './tools/list-sources.js';
+import { handleCheckFreshness } from './tools/check-freshness.js';
+import { handleSearchGrants } from './tools/search-grants.js';
+import { handleGetGrantDetails } from './tools/get-grant-details.js';
+import { handleGetPaymentRates } from './tools/get-payment-rates.js';
+import { handleCheckEligibility } from './tools/check-eligibility.js';
+import { handleListGrantOptions } from './tools/list-grant-options.js';
+import { handleGetApplicationDeadlines } from './tools/get-application-deadlines.js';
+import { handleSearchApplicationGuidance } from './tools/search-application-guidance.js';
+
+const SERVER_NAME = 'ch-farm-grants-mcp';
+const SERVER_VERSION = '0.1.0';
+
+const TOOLS = [
+  {
+    name: 'about',
+    description: 'Get server metadata: name, version, coverage, data sources, and links.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'list_sources',
+    description: 'List all data sources with authority, URL, license, and freshness info.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'check_data_freshness',
+    description: 'Check when data was last ingested, staleness status, and how to trigger a refresh.',
+    inputSchema: { type: 'object' as const, properties: {} },
+  },
+  {
+    name: 'search_grants',
+    description: 'Search Swiss agricultural structural improvement grants, investment credits, and funding programmes. Use for broad queries about Investitionskredite, Beitraege, Meliorationen, PRE.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query (German or English)' },
+        grant_type: { type: 'string', description: 'Filter by type: investitionskredit, beitrag, meliorationsbeitrag, pre, ressourcenprogramm, gewaesserschutz, starthilfe' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+        limit: { type: 'number', description: 'Max results (default: 20, max: 50)' },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'get_grant_details',
+    description: 'Get full details for a specific grant programme: objectives, contribution rates, conditions, eligibility rules, and sub-options.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        grant_id: { type: 'string', description: 'Grant ID or name (e.g. investitionskredit-oekonomiegebaeude, starthilfe-junglandwirte)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['grant_id'],
+    },
+  },
+  {
+    name: 'get_payment_rates',
+    description: 'Get federal and cantonal contribution rates for a grant programme, with zone-specific bonuses (Berggebiet, Huegelzone).',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        grant_id: { type: 'string', description: 'Grant ID or name' },
+        zone: { type: 'string', description: 'Altitude zone: talzone, huegelzone, bergzone_i, bergzone_ii, bergzone_iii, bergzone_iv, soemmerungsgebiet' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['grant_id'],
+    },
+  },
+  {
+    name: 'check_eligibility',
+    description: 'Check which grants a farm is eligible for based on farm type, planned investment, and altitude zone.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        farm_type: { type: 'string', description: 'Farm type: milchwirtschaft, ackerbau, mutterkuhhaltung, bergbetrieb, alpwirtschaft, gemischt, gemeinschaft, junglandwirt' },
+        investment_type: { type: 'string', description: 'Investment type: stallbau, hofduengerlager, wohnhaus, diversifikation, alpgebaeude, wegebau, wasserversorgung, biogasanlage, kaeserei' },
+        zone: { type: 'string', description: 'Altitude zone: talzone, huegelzone, bergzone_i-iv, soemmerungsgebiet' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['farm_type'],
+    },
+  },
+  {
+    name: 'list_grant_options',
+    description: 'List all sub-options (Massnahmen) within a grant programme, or list all grants with their option counts.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        grant_id: { type: 'string', description: 'Grant ID to list options for. If omitted, lists all grants.' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'get_application_deadlines',
+    description: 'Get application deadlines for grants, optionally filtered by canton (2-letter code: ZH, BE, LU, etc.).',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        grant_id: { type: 'string', description: 'Grant ID to check deadlines for' },
+        canton: { type: 'string', description: 'Canton code (e.g. ZH, BE, LU, SG, GR, VS, TI)' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+    },
+  },
+  {
+    name: 'search_application_guidance',
+    description: 'How to apply for Swiss farm grants: required documents, cantonal contacts, general process, and AGRIDEA advisory support.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        query: { type: 'string', description: 'Free-text search query about the application process' },
+        jurisdiction: { type: 'string', description: 'ISO 3166-1 alpha-2 code (default: CH)' },
+      },
+      required: ['query'],
+    },
+  },
+];
+
+const SearchGrantsArgsSchema = z.object({
+  query: z.string(),
+  grant_type: z.string().optional(),
+  jurisdiction: z.string().optional(),
+  limit: z.number().optional(),
+});
+
+const GrantDetailsArgsSchema = z.object({
+  grant_id: z.string(),
+  jurisdiction: z.string().optional(),
+});
+
+const PaymentRatesArgsSchema = z.object({
+  grant_id: z.string(),
+  zone: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const EligibilityArgsSchema = z.object({
+  farm_type: z.string(),
+  investment_type: z.string().optional(),
+  zone: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const ListGrantOptionsArgsSchema = z.object({
+  grant_id: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const DeadlinesArgsSchema = z.object({
+  grant_id: z.string().optional(),
+  canton: z.string().optional(),
+  jurisdiction: z.string().optional(),
+});
+
+const GuidanceArgsSchema = z.object({
+  query: z.string(),
+  jurisdiction: z.string().optional(),
+});
+
+function textResult(data: unknown) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }] };
+}
+
+function errorResult(message: string) {
+  return { content: [{ type: 'text' as const, text: JSON.stringify({ error: message }) }], isError: true };
+}
+
+const db = createDatabase();
+
+const server = new Server(
+  { name: SERVER_NAME, version: SERVER_VERSION },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args = {} } = request.params;
+
+  try {
+    switch (name) {
+      case 'about':
+        return textResult(handleAbout());
+      case 'list_sources':
+        return textResult(handleListSources(db));
+      case 'check_data_freshness':
+        return textResult(handleCheckFreshness(db));
+      case 'search_grants':
+        return textResult(handleSearchGrants(db, SearchGrantsArgsSchema.parse(args)));
+      case 'get_grant_details':
+        return textResult(handleGetGrantDetails(db, GrantDetailsArgsSchema.parse(args)));
+      case 'get_payment_rates':
+        return textResult(handleGetPaymentRates(db, PaymentRatesArgsSchema.parse(args)));
+      case 'check_eligibility':
+        return textResult(handleCheckEligibility(db, EligibilityArgsSchema.parse(args)));
+      case 'list_grant_options':
+        return textResult(handleListGrantOptions(db, ListGrantOptionsArgsSchema.parse(args)));
+      case 'get_application_deadlines':
+        return textResult(handleGetApplicationDeadlines(db, DeadlinesArgsSchema.parse(args)));
+      case 'search_application_guidance':
+        return textResult(handleSearchApplicationGuidance(db, GuidanceArgsSchema.parse(args)));
+      default:
+        return errorResult(`Unknown tool: ${name}`);
+    }
+  } catch (err) {
+    return errorResult(err instanceof Error ? err.message : String(err));
+  }
+});
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/tools/about.ts

@@ -0,0 +1,29 @@
+import { buildMeta } from '../metadata.js';
+import { SUPPORTED_JURISDICTIONS } from '../jurisdiction.js';
+
+export function handleAbout() {
+  return {
+    name: 'Switzerland Farm Grants MCP',
+    description:
+      'Swiss agricultural structural improvement grants based on the Strukturverbesserungsverordnung (SVV), ' +
+      'BLW investment credit guidelines, and cantonal funding programmes. Covers Investitionskredite (interest-free ' +
+      'loans), Beitraege (capital grants), Meliorationen, Projekte zur regionalen Entwicklung (PRE), ' +
+      'Ressourcenprogramme (Art. 77a/77b LwG), Gewaesserschutzprojekte (Art. 62a GSchG), and Starthilfe ' +
+      'Junglandwirte. All amounts in CHF.',
+    version: '0.1.0',
+    jurisdiction: [...SUPPORTED_JURISDICTIONS],
+    data_sources: [
+      'Strukturverbesserungsverordnung (SVV, SR 913.1)',
+      'BLW Weisungen Investitionskredite und Beitraege',
+      'Kantonale Landwirtschaftsaemter',
+      'AGRIDEA Beratungsunterlagen',
+    ],
+    tools_count: 10,
+    links: {
+      homepage: 'https://ansvar.eu/open-agriculture',
+      repository: 'https://github.com/ansvar-systems/ch-farm-grants-mcp',
+      mcp_network: 'https://ansvar.ai/mcp',
+    },
+    _meta: buildMeta(),
+  };
+}

package/src/tools/check-eligibility.ts

@@ -0,0 +1,81 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface EligibilityArgs {
+  farm_type: string;
+  investment_type?: string;
+  zone?: string;
+  jurisdiction?: string;
+}
+
+export function handleCheckEligibility(db: Database, args: EligibilityArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = `
+    SELECT DISTINCT g.id, g.name, g.grant_type, g.description, g.federal_rate_pct,
+           g.max_amount, g.duration_years, e.requirement, e.farm_type, e.investment_type, e.zone
+    FROM eligibility_rules e
+    JOIN grants g ON e.grant_id = g.id
+    WHERE g.jurisdiction = ?
+      AND (LOWER(e.farm_type) = LOWER(?) OR e.farm_type IS NULL OR e.farm_type = 'alle')
+  `;
+  const params: unknown[] = [jv.jurisdiction, args.farm_type];
+
+  if (args.investment_type) {
+    sql += ' AND (LOWER(e.investment_type) = LOWER(?) OR e.investment_type IS NULL OR e.investment_type = \'alle\')';
+    params.push(args.investment_type);
+  }
+
+  if (args.zone) {
+    sql += ' AND (LOWER(e.zone) = LOWER(?) OR e.zone IS NULL OR e.zone = \'alle\')';
+    params.push(args.zone);
+  }
+
+  sql += ' ORDER BY g.grant_type, g.name';
+
+  const rows = db.all<{
+    id: string; name: string; grant_type: string; description: string;
+    federal_rate_pct: number; max_amount: number; duration_years: number;
+    requirement: string; farm_type: string; investment_type: string; zone: string;
+  }>(sql, params);
+
+  // Group by grant
+  const grantMap = new Map<string, {
+    id: string; name: string; grant_type: string; description: string;
+    federal_rate_pct: number; max_amount: number; duration_years: number;
+    requirements: string[];
+  }>();
+
+  for (const row of rows) {
+    if (!grantMap.has(row.id)) {
+      grantMap.set(row.id, {
+        id: row.id,
+        name: row.name,
+        grant_type: row.grant_type,
+        description: row.description,
+        federal_rate_pct: row.federal_rate_pct,
+        max_amount: row.max_amount,
+        duration_years: row.duration_years,
+        requirements: [],
+      });
+    }
+    const entry = grantMap.get(row.id)!;
+    if (row.requirement && !entry.requirements.includes(row.requirement)) {
+      entry.requirements.push(row.requirement);
+    }
+  }
+
+  const eligible = Array.from(grantMap.values());
+
+  return {
+    farm_type: args.farm_type,
+    investment_type: args.investment_type ?? null,
+    zone: args.zone ?? null,
+    jurisdiction: jv.jurisdiction,
+    eligible_grants_count: eligible.length,
+    eligible_grants: eligible,
+    _meta: buildMeta(),
+  };
+}

package/src/tools/check-freshness.ts

@@ -0,0 +1,42 @@
+import { buildMeta } from '../metadata.js';
+import type { Database } from '../db.js';
+
+interface FreshnessResult {
+  status: 'fresh' | 'stale' | 'unknown';
+  last_ingest: string | null;
+  build_date: string | null;
+  schema_version: string | null;
+  days_since_ingest: number | null;
+  staleness_threshold_days: number;
+  refresh_command: string;
+  _meta: ReturnType<typeof buildMeta>;
+}
+
+const STALENESS_THRESHOLD_DAYS = 90;
+
+export function handleCheckFreshness(db: Database): FreshnessResult {
+  const lastIngest = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['last_ingest']);
+  const buildDate = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['build_date']);
+  const schemaVersion = db.get<{ value: string }>('SELECT value FROM db_metadata WHERE key = ?', ['schema_version']);
+
+  let status: 'fresh' | 'stale' | 'unknown' = 'unknown';
+  let daysSinceIngest: number | null = null;
+
+  if (lastIngest?.value) {
+    const ingestDate = new Date(lastIngest.value);
+    const now = new Date();
+    daysSinceIngest = Math.floor((now.getTime() - ingestDate.getTime()) / (1000 * 60 * 60 * 24));
+    status = daysSinceIngest <= STALENESS_THRESHOLD_DAYS ? 'fresh' : 'stale';
+  }
+
+  return {
+    status,
+    last_ingest: lastIngest?.value ?? null,
+    build_date: buildDate?.value ?? null,
+    schema_version: schemaVersion?.value ?? null,
+    days_since_ingest: daysSinceIngest,
+    staleness_threshold_days: STALENESS_THRESHOLD_DAYS,
+    refresh_command: 'gh workflow run ingest.yml -R ansvar-systems/ch-farm-grants-mcp',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-application-deadlines.ts

@@ -0,0 +1,55 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface DeadlineArgs {
+  grant_id?: string;
+  canton?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetApplicationDeadlines(db: Database, args: DeadlineArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  let sql = `
+    SELECT d.*, g.name as grant_name, g.grant_type
+    FROM application_deadlines d
+    JOIN grants g ON d.grant_id = g.id
+    WHERE g.jurisdiction = ?
+  `;
+  const params: unknown[] = [jv.jurisdiction];
+
+  if (args.grant_id) {
+    sql += ' AND (d.grant_id = ? OR LOWER(g.name) = LOWER(?))';
+    params.push(args.grant_id, args.grant_id);
+  }
+
+  if (args.canton) {
+    sql += ' AND (UPPER(d.canton) = UPPER(?) OR d.canton IS NULL OR d.canton = \'alle\')';
+    params.push(args.canton);
+  }
+
+  sql += ' ORDER BY d.deadline_date, g.name';
+
+  const deadlines = db.all<{
+    id: number; grant_id: string; grant_name: string; grant_type: string;
+    canton: string; deadline_date: string; notes: string;
+  }>(sql, params);
+
+  return {
+    grant_id: args.grant_id ?? null,
+    canton: args.canton ?? null,
+    jurisdiction: jv.jurisdiction,
+    deadlines_count: deadlines.length,
+    deadlines: deadlines.map(d => ({
+      grant_id: d.grant_id,
+      grant_name: d.grant_name,
+      grant_type: d.grant_type,
+      canton: d.canton,
+      deadline_date: d.deadline_date,
+      notes: d.notes,
+    })),
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-grant-details.ts

@@ -0,0 +1,51 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface GrantDetailsArgs {
+  grant_id: string;
+  jurisdiction?: string;
+}
+
+export function handleGetGrantDetails(db: Database, args: GrantDetailsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  const grant = db.get<{
+    id: string; name: string; grant_type: string; description: string;
+    federal_rate_pct: number; max_amount: number; duration_years: number;
+    zone_bonus: string; legal_basis: string; language: string; jurisdiction: string;
+  }>(
+    'SELECT * FROM grants WHERE (id = ? OR LOWER(name) = LOWER(?)) AND jurisdiction = ?',
+    [args.grant_id, args.grant_id, jv.jurisdiction]
+  );
+
+  if (!grant) {
+    return {
+      error: 'not_found',
+      message: `Grant '${args.grant_id}' not found. Use search_grants to find available grant programmes.`,
+    };
+  }
+
+  const options = db.all<{
+    option_name: string; description: string; rate: string; conditions: string;
+  }>(
+    'SELECT option_name, description, rate, conditions FROM grant_options WHERE grant_id = ?',
+    [grant.id]
+  );
+
+  const eligibility = db.all<{
+    farm_type: string; investment_type: string; zone: string; requirement: string;
+  }>(
+    'SELECT farm_type, investment_type, zone, requirement FROM eligibility_rules WHERE grant_id = ?',
+    [grant.id]
+  );
+
+  return {
+    ...grant,
+    zone_bonus: grant.zone_bonus ? JSON.parse(grant.zone_bonus) : null,
+    options: options.length > 0 ? options : [],
+    eligibility_rules: eligibility.length > 0 ? eligibility : [],
+    _meta: buildMeta(),
+  };
+}

package/src/tools/get-payment-rates.ts

@@ -0,0 +1,60 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface PaymentRatesArgs {
+  grant_id: string;
+  zone?: string;
+  jurisdiction?: string;
+}
+
+export function handleGetPaymentRates(db: Database, args: PaymentRatesArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  const grant = db.get<{
+    id: string; name: string; grant_type: string; federal_rate_pct: number;
+    max_amount: number; duration_years: number; zone_bonus: string;
+  }>(
+    'SELECT id, name, grant_type, federal_rate_pct, max_amount, duration_years, zone_bonus FROM grants WHERE (id = ? OR LOWER(name) = LOWER(?)) AND jurisdiction = ?',
+    [args.grant_id, args.grant_id, jv.jurisdiction]
+  );
+
+  if (!grant) {
+    return {
+      error: 'not_found',
+      message: `Grant '${args.grant_id}' not found. Use search_grants to find available grant programmes.`,
+    };
+  }
+
+  const zoneBonus = grant.zone_bonus ? JSON.parse(grant.zone_bonus) as Record<string, string> : null;
+
+  let applicableZoneInfo: string | null = null;
+  if (args.zone && zoneBonus) {
+    const zoneKey = Object.keys(zoneBonus).find(k => k.toLowerCase() === args.zone!.toLowerCase());
+    applicableZoneInfo = zoneKey ? zoneBonus[zoneKey] : null;
+  }
+
+  const options = db.all<{
+    option_name: string; rate: string; conditions: string;
+  }>(
+    'SELECT option_name, rate, conditions FROM grant_options WHERE grant_id = ?',
+    [grant.id]
+  );
+
+  return {
+    grant_id: grant.id,
+    grant_name: grant.name,
+    grant_type: grant.grant_type,
+    federal_rate_pct: grant.federal_rate_pct,
+    max_amount_chf: grant.max_amount,
+    duration_years: grant.duration_years,
+    zone_requested: args.zone ?? null,
+    zone_bonus: applicableZoneInfo,
+    all_zone_bonuses: zoneBonus,
+    rate_options: options,
+    jurisdiction: jv.jurisdiction,
+    currency: 'CHF',
+    _meta: buildMeta(),
+  };
+}

package/src/tools/list-grant-options.ts

@@ -0,0 +1,63 @@
+import { buildMeta } from '../metadata.js';
+import { validateJurisdiction } from '../jurisdiction.js';
+import type { Database } from '../db.js';
+
+interface ListGrantOptionsArgs {
+  grant_id?: string;
+  jurisdiction?: string;
+}
+
+export function handleListGrantOptions(db: Database, args: ListGrantOptionsArgs) {
+  const jv = validateJurisdiction(args.jurisdiction);
+  if (!jv.valid) return jv.error;
+
+  if (args.grant_id) {
+    const grant = db.get<{ id: string; name: string }>(
+      'SELECT id, name FROM grants WHERE (id = ? OR LOWER(name) = LOWER(?)) AND jurisdiction = ?',
+      [args.grant_id, args.grant_id, jv.jurisdiction]
+    );
+
+    if (!grant) {
+      return {
+        error: 'not_found',
+        message: `Grant '${args.grant_id}' not found. Use search_grants to find available grant programmes.`,
+      };
+    }
+
+    const options = db.all<{
+      id: number; option_name: string; description: string; rate: string; conditions: string;
+    }>(
+      'SELECT id, option_name, description, rate, conditions FROM grant_options WHERE grant_id = ?',
+      [grant.id]
+    );
+
+    return {
+      grant_id: grant.id,
+      grant_name: grant.name,
+      jurisdiction: jv.jurisdiction,
+      options_count: options.length,
+      options,
+      _meta: buildMeta(),
+    };
+  }
+
+  // List all grants with their option counts
+  const grants = db.all<{
+    id: string; name: string; grant_type: string; option_count: number;
+  }>(
+    `SELECT g.id, g.name, g.grant_type, COUNT(o.id) as option_count
+     FROM grants g
+     LEFT JOIN grant_options o ON g.id = o.grant_id
+     WHERE g.jurisdiction = ?
+     GROUP BY g.id
+     ORDER BY g.grant_type, g.name`,
+    [jv.jurisdiction]
+  );
+
+  return {
+    jurisdiction: jv.jurisdiction,
+    grants_count: grants.length,
+    grants,
+    _meta: buildMeta(),
+  };
+}

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: 'Strukturverbesserungsverordnung (SVV, SR 913.1)',
+      authority: 'Bundesamt fuer Landwirtschaft (BLW)',
+      official_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/strukturverbesserungen.html',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual (with ordinance updates)',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Investment credits, capital grants, eligibility criteria, contribution rates',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'BLW Weisungen Investitionskredite und Beitraege',
+      authority: 'Bundesamt fuer Landwirtschaft (BLW)',
+      official_url: 'https://www.blw.admin.ch/blw/de/home/instrumente/strukturverbesserungen/investitionskredite.html',
+      retrieval_method: 'PDF_EXTRACT',
+      update_frequency: 'annual',
+      license: 'Swiss Federal Administration — free reuse',
+      coverage: 'Detailed rules on investment credit eligibility, loan terms, project types',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'Kantonale Landwirtschaftsaemter — Strukturverbesserungen',
+      authority: 'Kantonale Landwirtschaftsaemter',
+      official_url: 'https://www.agridea.ch',
+      retrieval_method: 'MANUAL_RESEARCH',
+      update_frequency: 'variable (per canton)',
+      license: 'Cantonal public information',
+      coverage: 'Cantonal contribution rates, additional cantonal programmes, deadlines',
+      last_retrieved: lastIngest?.value,
+    },
+    {
+      name: 'AGRIDEA Beratungsunterlagen Strukturverbesserungen',
+      authority: 'AGRIDEA',
+      official_url: 'https://www.agridea.ch',
+      retrieval_method: 'MANUAL_RESEARCH',
+      update_frequency: 'periodic',
+      license: 'AGRIDEA — educational use',
+      coverage: 'Project planning guidance, application procedures, cost estimates',
+      last_retrieved: lastIngest?.value,
+    },
+  ];
+
+  return {
+    sources,
+    _meta: buildMeta(),
+  };
+}