@ansvar/eu-regulations-mcp 0.1.0

package/src/tools/applicability.ts

@@ -0,0 +1,84 @@
+import type { Database } from 'better-sqlite3';
+
+export type Sector =
+  | 'financial'
+  | 'healthcare'
+  | 'energy'
+  | 'transport'
+  | 'digital_infrastructure'
+  | 'public_administration'
+  | 'manufacturing'
+  | 'other';
+
+export interface ApplicabilityInput {
+  sector: Sector;
+  subsector?: string;
+  member_state?: string;
+  size?: 'sme' | 'large';
+}
+
+export interface ApplicableRegulation {
+  regulation: string;
+  confidence: 'definite' | 'likely' | 'possible';
+  basis: string | null;
+  notes: string | null;
+}
+
+export interface ApplicabilityResult {
+  entity: ApplicabilityInput;
+  applicable_regulations: ApplicableRegulation[];
+}
+
+export async function checkApplicability(
+  db: Database,
+  input: ApplicabilityInput
+): Promise<ApplicabilityResult> {
+  const { sector, subsector } = input;
+
+  // Query for matching rules - check both sector match and subsector match
+  let sql = `
+    SELECT DISTINCT
+      regulation,
+      confidence,
+      basis_article as basis,
+      notes
+    FROM applicability_rules
+    WHERE applies = 1
+      AND (
+        (sector = ? AND (subsector IS NULL OR subsector = ?))
+        OR (sector = ? AND subsector IS NULL)
+      )
+    ORDER BY
+      CASE confidence
+        WHEN 'definite' THEN 1
+        WHEN 'likely' THEN 2
+        WHEN 'possible' THEN 3
+      END,
+      regulation
+  `;
+
+  const rows = db.prepare(sql).all(sector, subsector || '', sector) as Array<{
+    regulation: string;
+    confidence: 'definite' | 'likely' | 'possible';
+    basis: string | null;
+    notes: string | null;
+  }>;
+
+  // Deduplicate by regulation, keeping highest confidence
+  const regulationMap = new Map<string, ApplicableRegulation>();
+  for (const row of rows) {
+    if (!regulationMap.has(row.regulation)) {
+      regulationMap.set(row.regulation, {
+        regulation: row.regulation,
+        confidence: row.confidence,
+        basis: row.basis,
+        notes: row.notes,
+      });
+    }
+  }
+
+  return {
+    entity: input,
+    applicable_regulations: Array.from(regulationMap.values()),
+  };
+}

package/src/tools/article.ts

@@ -0,0 +1,61 @@
+import type { Database } from 'better-sqlite3';
+
+export interface GetArticleInput {
+  regulation: string;
+  article: string;
+  include_recitals?: boolean;
+}
+
+export interface Article {
+  regulation: string;
+  article_number: string;
+  title: string | null;
+  text: string;
+  chapter: string | null;
+  recitals: string[] | null;
+  cross_references: string[] | null;
+}
+
+export async function getArticle(
+  db: Database,
+  input: GetArticleInput
+): Promise<Article | null> {
+  const { regulation, article } = input;
+
+  const sql = `
+    SELECT
+      regulation,
+      article_number,
+      title,
+      text,
+      chapter,
+      recitals,
+      cross_references
+    FROM articles
+    WHERE regulation = ? AND article_number = ?
+  `;
+
+  const row = db.prepare(sql).get(regulation, article) as {
+    regulation: string;
+    article_number: string;
+    title: string | null;
+    text: string;
+    chapter: string | null;
+    recitals: string | null;
+    cross_references: string | null;
+  } | undefined;
+
+  if (!row) {
+    return null;
+  }
+
+  return {
+    regulation: row.regulation,
+    article_number: row.article_number,
+    title: row.title,
+    text: row.text,
+    chapter: row.chapter,
+    recitals: row.recitals ? JSON.parse(row.recitals) : null,
+    cross_references: row.cross_references ? JSON.parse(row.cross_references) : null,
+  };
+}

package/src/tools/compare.ts

@@ -0,0 +1,94 @@
+import type { Database } from 'better-sqlite3';
+import { searchRegulations } from './search.js';
+
+export interface CompareInput {
+  topic: string;
+  regulations: string[];
+}
+
+export interface RegulationComparison {
+  regulation: string;
+  requirements: string[];
+  articles: string[];
+  timelines?: string;
+}
+
+export interface CompareResult {
+  topic: string;
+  regulations: RegulationComparison[];
+  key_differences?: string[];
+}
+
+/**
+ * Extract timeline mentions from text (e.g., "24 hours", "72 hours")
+ */
+function extractTimelines(text: string): string | undefined {
+  const timelinePatterns = [
+    /(\d+)\s*hours?/gi,
+    /(\d+)\s*days?/gi,
+    /without\s+undue\s+delay/gi,
+    /immediately/gi,
+  ];
+
+  const matches: string[] = [];
+  for (const pattern of timelinePatterns) {
+    const found = text.match(pattern);
+    if (found) {
+      matches.push(...found);
+    }
+  }
+
+  return matches.length > 0 ? matches.join(', ') : undefined;
+}
+
+export async function compareRequirements(
+  db: Database,
+  input: CompareInput
+): Promise<CompareResult> {
+  const { topic, regulations } = input;
+
+  const comparisons: RegulationComparison[] = [];
+
+  for (const regulation of regulations) {
+    // Search for articles matching the topic in this regulation
+    const results = await searchRegulations(db, {
+      query: topic,
+      regulations: [regulation],
+      limit: 5,
+    });
+
+    // Get full article text for timeline extraction
+    const articles: string[] = [];
+    const requirements: string[] = [];
+    let combinedText = '';
+
+    for (const result of results) {
+      articles.push(result.article);
+      requirements.push(result.snippet.replace(/>>>/g, '').replace(/<<</g, ''));
+
+      // Get full text for timeline extraction
+      const fullArticle = db.prepare(`
+        SELECT text FROM articles
+        WHERE regulation = ? AND article_number = ?
+      `).get(regulation, result.article) as { text: string } | undefined;
+
+      if (fullArticle) {
+        combinedText += ' ' + fullArticle.text;
+      }
+    }
+
+    const timelines = extractTimelines(combinedText);
+
+    comparisons.push({
+      regulation,
+      requirements,
+      articles,
+      timelines,
+    });
+  }
+
+  return {
+    topic,
+    regulations: comparisons,
+  };
+}

package/src/tools/definitions.ts

@@ -0,0 +1,54 @@
+import type { Database } from 'better-sqlite3';
+
+export interface DefinitionsInput {
+  term: string;
+  regulation?: string;
+}
+
+export interface Definition {
+  term: string;
+  regulation: string;
+  article: string;
+  definition: string;
+  related_terms?: string[];
+}
+
+export async function getDefinitions(
+  db: Database,
+  input: DefinitionsInput
+): Promise<Definition[]> {
+  const { term, regulation } = input;
+
+  let sql = `
+    SELECT
+      term,
+      regulation,
+      article,
+      definition
+    FROM definitions
+    WHERE term LIKE ?
+  `;
+
+  const params: string[] = [`%${term}%`];
+
+  if (regulation) {
+    sql += ` AND regulation = ?`;
+    params.push(regulation);
+  }
+
+  sql += ` ORDER BY regulation, term`;
+
+  const rows = db.prepare(sql).all(...params) as Array<{
+    term: string;
+    regulation: string;
+    article: string;
+    definition: string;
+  }>;
+
+  return rows.map(row => ({
+    term: row.term,
+    regulation: row.regulation,
+    article: row.article,
+    definition: row.definition,
+  }));
+}

package/src/tools/list.ts

@@ -0,0 +1,116 @@
+import type { Database } from 'better-sqlite3';
+
+export interface ListInput {
+  regulation?: string;
+}
+
+export interface Chapter {
+  number: string;
+  title: string;
+  articles: string[];
+}
+
+export interface RegulationInfo {
+  id: string;
+  full_name: string;
+  celex_id: string;
+  effective_date: string | null;
+  article_count: number;
+  chapters?: Chapter[];
+}
+
+export interface ListResult {
+  regulations: RegulationInfo[];
+}
+
+export async function listRegulations(
+  db: Database,
+  input: ListInput
+): Promise<ListResult> {
+  const { regulation } = input;
+
+  if (regulation) {
+    // Get specific regulation with chapters
+    const regRow = db.prepare(`
+      SELECT id, full_name, celex_id, effective_date
+      FROM regulations
+      WHERE id = ?
+    `).get(regulation) as {
+      id: string;
+      full_name: string;
+      celex_id: string;
+      effective_date: string | null;
+    } | undefined;
+
+    if (!regRow) {
+      return { regulations: [] };
+    }
+
+    // Get articles grouped by chapter
+    const articles = db.prepare(`
+      SELECT article_number, title, chapter
+      FROM articles
+      WHERE regulation = ?
+      ORDER BY CAST(article_number AS INTEGER)
+    `).all(regulation) as Array<{
+      article_number: string;
+      title: string | null;
+      chapter: string | null;
+    }>;
+
+    // Group by chapter
+    const chapterMap = new Map<string, Chapter>();
+    for (const article of articles) {
+      const chapterKey = article.chapter || 'General';
+      if (!chapterMap.has(chapterKey)) {
+        chapterMap.set(chapterKey, {
+          number: chapterKey,
+          title: `Chapter ${chapterKey}`,
+          articles: [],
+        });
+      }
+      chapterMap.get(chapterKey)!.articles.push(article.article_number);
+    }
+
+    return {
+      regulations: [{
+        id: regRow.id,
+        full_name: regRow.full_name,
+        celex_id: regRow.celex_id,
+        effective_date: regRow.effective_date,
+        article_count: articles.length,
+        chapters: Array.from(chapterMap.values()),
+      }],
+    };
+  }
+
+  // List all regulations with article counts
+  const rows = db.prepare(`
+    SELECT
+      r.id,
+      r.full_name,
+      r.celex_id,
+      r.effective_date,
+      COUNT(a.rowid) as article_count
+    FROM regulations r
+    LEFT JOIN articles a ON a.regulation = r.id
+    GROUP BY r.id
+    ORDER BY r.id
+  `).all() as Array<{
+    id: string;
+    full_name: string;
+    celex_id: string;
+    effective_date: string | null;
+    article_count: number;
+  }>;
+
+  return {
+    regulations: rows.map(row => ({
+      id: row.id,
+      full_name: row.full_name,
+      celex_id: row.celex_id,
+      effective_date: row.effective_date,
+      article_count: row.article_count,
+    })),
+  };
+}

package/src/tools/map.ts

@@ -0,0 +1,84 @@
+import type { Database } from 'better-sqlite3';
+
+export interface MapControlsInput {
+  framework: 'ISO27001';
+  control?: string;
+  regulation?: string;
+}
+
+export interface ControlMappingEntry {
+  regulation: string;
+  articles: string[];
+  coverage: 'full' | 'partial' | 'related';
+  notes: string | null;
+}
+
+export interface ControlMapping {
+  control_id: string;
+  control_name: string;
+  mappings: ControlMappingEntry[];
+}
+
+export async function mapControls(
+  db: Database,
+  input: MapControlsInput
+): Promise<ControlMapping[]> {
+  const { control, regulation } = input;
+
+  let sql = `
+    SELECT
+      control_id,
+      control_name,
+      regulation,
+      articles,
+      coverage,
+      notes
+    FROM control_mappings
+    WHERE 1=1
+  `;
+
+  const params: string[] = [];
+
+  if (control) {
+    sql += ` AND control_id = ?`;
+    params.push(control);
+  }
+
+  if (regulation) {
+    sql += ` AND regulation = ?`;
+    params.push(regulation);
+  }
+
+  sql += ` ORDER BY control_id, regulation`;
+
+  const rows = db.prepare(sql).all(...params) as Array<{
+    control_id: string;
+    control_name: string;
+    regulation: string;
+    articles: string;
+    coverage: 'full' | 'partial' | 'related';
+    notes: string | null;
+  }>;
+
+  // Group by control_id
+  const controlMap = new Map<string, ControlMapping>();
+
+  for (const row of rows) {
+    if (!controlMap.has(row.control_id)) {
+      controlMap.set(row.control_id, {
+        control_id: row.control_id,
+        control_name: row.control_name,
+        mappings: [],
+      });
+    }
+
+    controlMap.get(row.control_id)!.mappings.push({
+      regulation: row.regulation,
+      articles: JSON.parse(row.articles),
+      coverage: row.coverage,
+      notes: row.notes,
+    });
+  }
+
+  return Array.from(controlMap.values());
+}

package/src/tools/search.ts

@@ -0,0 +1,95 @@
+import type { Database } from 'better-sqlite3';
+
+export interface SearchInput {
+  query: string;
+  regulations?: string[];
+  limit?: number;
+}
+
+export interface SearchResult {
+  regulation: string;
+  article: string;
+  title: string;
+  snippet: string;
+  relevance: number;
+}
+
+/**
+ * Escape special FTS5 query characters to prevent syntax errors.
+ * FTS5 uses double quotes for phrase queries and has special operators.
+ */
+function escapeFts5Query(query: string): string {
+  // Remove characters that have special meaning in FTS5
+  // and wrap each word in double quotes for exact matching
+  return query
+    .replace(/['"]/g, '') // Remove quotes
+    .split(/\s+/)
+    .filter(word => word.length > 0)
+    .map(word => `"${word}"`)
+    .join(' ');
+}
+
+export async function searchRegulations(
+  db: Database,
+  input: SearchInput
+): Promise<SearchResult[]> {
+  const { query, regulations, limit = 10 } = input;
+
+  if (!query || query.trim().length === 0) {
+    return [];
+  }
+
+  const escapedQuery = escapeFts5Query(query);
+
+  if (!escapedQuery) {
+    return [];
+  }
+
+  // Build the SQL query with optional regulation filter
+  let sql = `
+    SELECT
+      articles_fts.regulation,
+      articles_fts.article_number as article,
+      articles_fts.title,
+      snippet(articles_fts, 3, '>>>', '<<<', '...', 32) as snippet,
+      bm25(articles_fts) as relevance
+    FROM articles_fts
+    WHERE articles_fts MATCH ?
+  `;
+
+  const params: (string | number)[] = [escapedQuery];
+
+  if (regulations && regulations.length > 0) {
+    const placeholders = regulations.map(() => '?').join(', ');
+    sql += ` AND articles_fts.regulation IN (${placeholders})`;
+    params.push(...regulations);
+  }
+
+  // Order by relevance (bm25 returns negative scores, more negative = more relevant)
+  sql += ` ORDER BY bm25(articles_fts)`;
+  sql += ` LIMIT ?`;
+  params.push(limit);
+
+  try {
+    const stmt = db.prepare(sql);
+    const rows = stmt.all(...params) as Array<{
+      regulation: string;
+      article: string;
+      title: string;
+      snippet: string;
+      relevance: number;
+    }>;
+
+    // Convert bm25 scores to positive values (higher = more relevant)
+    return rows.map(row => ({
+      ...row,
+      relevance: Math.abs(row.relevance),
+    }));
+  } catch (error) {
+    // If FTS5 query fails (e.g., syntax error), return empty results
+    if (error instanceof Error && error.message.includes('fts5')) {
+      return [];
+    }
+    throw error;
+  }
+}