law-mcp-server 0.1.0

package/dist/src/tools.js

@@ -0,0 +1,134 @@
+import { fetchLawData, searchLaws } from "./lawApi.js";
+import { checkConsistency } from "./consistency.js";
+const requireString = (value, field) => {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Field ${field} is required`);
+    }
+    return value.trim();
+};
+const requireArrayOfStrings = (value, field) => {
+    if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+        throw new Error(`Field ${field} must be an array of strings`);
+    }
+    return value;
+};
+const fetchLaw = {
+    name: "fetch_law",
+    description: "Fetch a law by LawID and optional revision date",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lawId: { type: "string" },
+            revisionDate: { type: "string" },
+        },
+        required: ["lawId"],
+    },
+    handler: async (input) => {
+        const lawId = requireString(input.lawId, "lawId");
+        const revisionDate = typeof input.revisionDate === "string" ? input.revisionDate : undefined;
+        const data = await fetchLawData(lawId, revisionDate);
+        return [{ type: "json", data }];
+    },
+};
+const search = {
+    name: "search_laws",
+    description: "Search laws by keyword",
+    inputSchema: {
+        type: "object",
+        properties: {
+            keyword: { type: "string" },
+        },
+        required: ["keyword"],
+    },
+    handler: async (input) => {
+        const keyword = requireString(input.keyword, "keyword");
+        const results = await searchLaws(keyword);
+        return [{ type: "json", data: results }];
+    },
+};
+const summarize = {
+    name: "summarize_law",
+    description: "Summarize a law or selected articles",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lawId: { type: "string" },
+            articles: { type: "array", items: { type: "string" } },
+        },
+        required: ["lawId"],
+    },
+    handler: async (input) => {
+        const lawId = requireString(input.lawId, "lawId");
+        const articlesFilter = Array.isArray(input.articles)
+            ? requireArrayOfStrings(input.articles, "articles")
+            : undefined;
+        const data = await fetchLawData(lawId);
+        const articles = Array.isArray(data.LawBody?.MainProvision?.Article)
+            ? data.LawBody?.MainProvision?.Article
+            : data.LawBody?.MainProvision?.Article
+                ? [data.LawBody.MainProvision.Article]
+                : [];
+        const filtered = articlesFilter
+            ? articles.filter((article) => article.ArticleNumber &&
+                articlesFilter.includes(article.ArticleNumber))
+            : articles;
+        const body = filtered
+            .map((article) => `${article.ArticleNumber || ""} ${article.ArticleTitle || ""}`.trim())
+            .slice(0, 10)
+            .join("\n");
+        return [{ type: "text", text: body || "No articles available" }];
+    },
+};
+const listRevisions = {
+    name: "list_revisions",
+    description: "List known revisions for a law if provided by the API",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lawId: { type: "string" },
+        },
+        required: ["lawId"],
+    },
+    handler: async (input) => {
+        const lawId = requireString(input.lawId, "lawId");
+        const data = await fetchLawData(lawId);
+        const revisions = Array.isArray(data.revisions)
+            ? data.revisions
+            : [];
+        return [{ type: "json", data: { lawId, revisions } }];
+    },
+};
+const check = {
+    name: "check_consistency",
+    description: "Check a document against one or more laws",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentText: { type: "string" },
+            lawIds: { type: "array", items: { type: "string" } },
+            articleHints: { type: "array", items: { type: "string" } },
+            strictness: { type: "string", enum: ["low", "medium", "high"] },
+        },
+        required: ["documentText"],
+    },
+    handler: async (input) => {
+        const documentText = requireString(input.documentText, "documentText");
+        const lawIds = Array.isArray(input.lawIds)
+            ? requireArrayOfStrings(input.lawIds, "lawIds")
+            : [];
+        if (!lawIds.length) {
+            throw new Error("At least one lawId is required for consistency checks");
+        }
+        const laws = await Promise.all(lawIds.map((lawId) => fetchLawData(lawId)));
+        const output = checkConsistency(documentText, laws);
+        return [{ type: "json", data: output }];
+    },
+};
+export const tools = [
+    fetchLaw,
+    search,
+    listRevisions,
+    check,
+    summarize,
+];
+export const resolveTool = (name) => tools.find((tool) => tool.name === name);

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/test/integration.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert";
+import { MockAgent, setGlobalDispatcher } from "undici";
+import { fetchLawData, searchLaws } from "../src/lawApi.js";
+import { checkConsistency } from "../src/consistency.js";
+const mockAgent = new MockAgent();
+mockAgent.disableNetConnect();
+const mockPool = mockAgent.get("https://laws.e-gov.go.jp");
+mockPool
+    .intercept({ path: "/api/2/lawdata/TEST-LAW", method: "GET" })
+    .reply(200, {
+    LawID: "TEST-LAW",
+    LawName: "テスト法",
+    LawBody: {
+        MainProvision: {
+            Article: [
+                {
+                    ArticleNumber: "第1条",
+                    ArticleTitle: "（目的）",
+                    Paragraph: {
+                        ParagraphSentence: "この法律はテスト目的のために存在する。",
+                    },
+                },
+                {
+                    ArticleNumber: "第2条",
+                    ArticleTitle: "（定義）",
+                    Paragraph: { ParagraphSentence: "用語の定義を定める。" },
+                },
+            ],
+        },
+    },
+});
+mockPool
+    .intercept({
+    path: "/api/2/lawsearch/%E3%83%86%E3%82%B9%E3%83%88",
+    method: "GET",
+})
+    .reply(200, {
+    numberOfHits: 1,
+    referencelaw: {
+        LawID: "TEST-LAW",
+        LawName: "テスト法",
+        PromulgationDate: "2024-01-01",
+    },
+});
+setGlobalDispatcher(mockAgent);
+const run = async () => {
+    // fetchLawData returns structured law
+    const law = await fetchLawData("TEST-LAW");
+    assert.strictEqual(law.LawID, "TEST-LAW");
+    assert.ok(law.LawBody?.MainProvision?.Article);
+    // searchLaws returns the mocked hit
+    const search = await searchLaws("テスト");
+    assert.strictEqual(search.numberOfHits, 1);
+    // consistency check aligns a segment with 第1条
+    const doc = "この法律はテスト目的のために存在する。";
+    const result = checkConsistency(doc, [law]);
+    assert.strictEqual(result.findings.length, 1);
+    const finding = result.findings[0];
+    assert.notStrictEqual(finding.status, "not_found");
+    assert.strictEqual(finding.articleNumber, "第1条");
+    console.log("integration tests passed");
+};
+run().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/tools.js

@@ -0,0 +1,123 @@
+import { fetchLawData, searchLaws } from "./lawApi.js";
+import { checkConsistency } from "./consistency.js";
+const requireString = (value, field) => {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`Field ${field} is required`);
+    }
+    return value.trim();
+};
+const requireArrayOfStrings = (value, field) => {
+    if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+        throw new Error(`Field ${field} must be an array of strings`);
+    }
+    return value;
+};
+const fetchLaw = {
+    name: "fetch_law",
+    description: "Fetch a law by LawID and optional revision date",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lawId: { type: "string" },
+            revisionDate: { type: "string" }
+        },
+        required: ["lawId"]
+    },
+    handler: async (input) => {
+        const lawId = requireString(input.lawId, "lawId");
+        const revisionDate = typeof input.revisionDate === "string" ? input.revisionDate : undefined;
+        const data = await fetchLawData(lawId, revisionDate);
+        return [{ type: "json", data }];
+    }
+};
+const search = {
+    name: "search_laws",
+    description: "Search laws by keyword",
+    inputSchema: {
+        type: "object",
+        properties: {
+            keyword: { type: "string" }
+        },
+        required: ["keyword"]
+    },
+    handler: async (input) => {
+        const keyword = requireString(input.keyword, "keyword");
+        const results = await searchLaws(keyword);
+        return [{ type: "json", data: results }];
+    }
+};
+const summarize = {
+    name: "summarize_law",
+    description: "Summarize a law or selected articles",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lawId: { type: "string" },
+            articles: { type: "array", items: { type: "string" } }
+        },
+        required: ["lawId"]
+    },
+    handler: async (input) => {
+        const lawId = requireString(input.lawId, "lawId");
+        const articlesFilter = Array.isArray(input.articles) ? requireArrayOfStrings(input.articles, "articles") : undefined;
+        const data = await fetchLawData(lawId);
+        const articles = Array.isArray(data.LawBody?.MainProvision?.Article)
+            ? data.LawBody?.MainProvision?.Article
+            : data.LawBody?.MainProvision?.Article
+                ? [data.LawBody.MainProvision.Article]
+                : [];
+        const filtered = articlesFilter
+            ? articles.filter((article) => article.ArticleNumber && articlesFilter.includes(article.ArticleNumber))
+            : articles;
+        const body = filtered
+            .map((article) => `${article.ArticleNumber || ""} ${article.ArticleTitle || ""}`.trim())
+            .slice(0, 10)
+            .join("\n");
+        return [{ type: "text", text: body || "No articles available" }];
+    }
+};
+const listRevisions = {
+    name: "list_revisions",
+    description: "List known revisions for a law if provided by the API",
+    inputSchema: {
+        type: "object",
+        properties: {
+            lawId: { type: "string" }
+        },
+        required: ["lawId"]
+    },
+    handler: async (input) => {
+        const lawId = requireString(input.lawId, "lawId");
+        const data = await fetchLawData(lawId);
+        const revisions = Array.isArray(data.revisions)
+            ? data.revisions
+            : [];
+        return [{ type: "json", data: { lawId, revisions } }];
+    }
+};
+const check = {
+    name: "check_consistency",
+    description: "Check a document against one or more laws",
+    inputSchema: {
+        type: "object",
+        properties: {
+            documentText: { type: "string" },
+            lawIds: { type: "array", items: { type: "string" } },
+            articleHints: { type: "array", items: { type: "string" } },
+            strictness: { type: "string", enum: ["low", "medium", "high"] }
+        },
+        required: ["documentText"]
+    },
+    handler: async (input) => {
+        const documentText = requireString(input.documentText, "documentText");
+        const lawIds = Array.isArray(input.lawIds) ? requireArrayOfStrings(input.lawIds, "lawIds") : [];
+        if (!lawIds.length) {
+            throw new Error("At least one lawId is required for consistency checks");
+        }
+        const laws = await Promise.all(lawIds.map((lawId) => fetchLawData(lawId)));
+        const output = checkConsistency(documentText, laws);
+        return [{ type: "json", data: output }];
+    }
+};
+export const tools = [fetchLaw, search, listRevisions, check, summarize];
+export const resolveTool = (name) => tools.find((tool) => tool.name === name);

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "law-mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP server for e-Gov law API consistency checks",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "format": "prettier --write .",
+    "test": "npm run build && node dist/test/integration.test.js"
+  },
+  "dependencies": {
+    "undici": "^6.13.0"
+  },
+  "devDependencies": {
+    "ts-node": "^10.9.2",
+    "typescript": "5.3.3",
+    "@types/node": "^20.11.0",
+    "eslint": "^8.57.0",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.2.5"
+  }
+}

package/src/cache.ts

@@ -0,0 +1,25 @@
+type Entry<T> = {
+  value: T;
+  expiresAt: number;
+};
+
+export class MemoryCache<T> {
+  private store = new Map<string, Entry<T>>();
+
+  get(key: string): T | undefined {
+    const entry = this.store.get(key);
+    if (!entry) return undefined;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return undefined;
+    }
+    return entry.value;
+  }
+
+  set(key: string, value: T, ttlSeconds: number) {
+    const expiresAt = Date.now() + ttlSeconds * 1000;
+    this.store.set(key, { value, expiresAt });
+  }
+}
+
+export const cache = new MemoryCache<unknown>();

package/src/config.ts

@@ -0,0 +1,19 @@
+export type AppConfig = {
+  apiBase: string;
+  httpTimeoutMs: number;
+  cacheTtlSeconds: number;
+  userAgent: string;
+};
+
+const toNumber = (value: string | undefined, fallback: number) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+
+export const config: AppConfig = {
+  apiBase:
+    process.env.LAW_API_BASE?.trim() || "https://laws.e-gov.go.jp/api/2/",
+  httpTimeoutMs: toNumber(process.env.HTTP_TIMEOUT_MS, 15000),
+  cacheTtlSeconds: toNumber(process.env.CACHE_TTL_SECONDS, 900),
+  userAgent: "law-mcp-server/0.1.0",
+};

package/src/consistency.ts

@@ -0,0 +1,128 @@
+import {
+  LawArticle,
+  LawData,
+  ConsistencyFinding,
+  ConsistencyOutput,
+} from "./types.js";
+
+type FlattenedArticle = {
+  lawId: string;
+  articleNumber?: string;
+  text: string;
+};
+
+const toArray = <T>(value: T | T[] | undefined): T[] => {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+};
+
+const paragraphText = (paragraph: unknown): string => {
+  if (!paragraph || typeof paragraph !== "object") return "";
+  const p = paragraph as { ParagraphSentence?: string | string[] };
+  const sentences = toArray(p.ParagraphSentence);
+  return sentences.join("\n");
+};
+
+const articleText = (article: LawArticle): string => {
+  const paragraphs = toArray(article.Paragraph);
+  const body = paragraphs.map(paragraphText).filter(Boolean).join("\n");
+  const title = article.ArticleTitle || "";
+  return [title, body].filter(Boolean).join("\n");
+};
+
+const flattenArticles = (law: LawData): FlattenedArticle[] => {
+  const articles = toArray(law.LawBody?.MainProvision?.Article);
+  return articles.map((article) => ({
+    lawId: law.LawID,
+    articleNumber: article.ArticleNumber,
+    text: articleText(article),
+  }));
+};
+
+const similarityScore = (a: string, b: string): number => {
+  const tokenize = (value: string) =>
+    value
+      .replace(/[\s、。,．.\n\t]+/g, " ")
+      .split(" ")
+      .map((v) => v.trim())
+      .filter(Boolean);
+  const tokensA = tokenize(a.toLowerCase());
+  const tokensB = tokenize(b.toLowerCase());
+  if (!tokensA.length || !tokensB.length) return 0;
+  const setB = new Set(tokensB);
+  const intersection = tokensA.filter((token) => setB.has(token)).length;
+  const union = new Set([...tokensA, ...tokensB]).size;
+  return intersection / union;
+};
+
+const extractArticleHint = (segment: string): string | undefined => {
+  const match = segment.match(
+    /第\s*([0-9０-９一二三四五六七八九十百千]+)\s*条/
+  );
+  return match ? match[1] : undefined;
+};
+
+const bestArticleMatch = (
+  segment: string,
+  articles: FlattenedArticle[]
+): FlattenedArticle | undefined => {
+  const hint = extractArticleHint(segment);
+  if (hint) {
+    const exact = articles.find(
+      (a) => a.articleNumber && a.articleNumber.includes(hint)
+    );
+    if (exact) return exact;
+  }
+  let best: FlattenedArticle | undefined;
+  let bestScore = 0;
+  for (const article of articles) {
+    const score = similarityScore(segment, article.text);
+    if (score > bestScore) {
+      best = article;
+      bestScore = score;
+    }
+  }
+  return best;
+};
+
+export const checkConsistency = (
+  documentText: string,
+  laws: LawData[]
+): ConsistencyOutput => {
+  const segments = documentText
+    .split(/\n+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  const flattened = laws
+    .flatMap(flattenArticles)
+    .filter((a) => a.text.trim().length > 0);
+
+  const findings: ConsistencyFinding[] = segments.map((segment) => {
+    const match = bestArticleMatch(segment, flattened);
+    if (!match) {
+      return { segment, status: "not_found" };
+    }
+    const score = similarityScore(segment, match.text);
+    const status =
+      score >= 0.6
+        ? "aligned"
+        : score >= 0.25
+          ? "potential_mismatch"
+          : "not_found";
+    return {
+      segment,
+      status,
+      lawId: match.lawId,
+      articleNumber: match.articleNumber,
+      lawSnippet: match.text.slice(0, 400),
+      score: Number(score.toFixed(3)),
+    };
+  });
+
+  const matchedLawIds = Array.from(
+    new Set(findings.map((f) => f.lawId).filter(Boolean))
+  ) as string[];
+
+  return { findings, matchedLawIds };
+};

package/src/index.ts

@@ -0,0 +1,34 @@
+import { StdioJsonRpcServer } from "./mcp.js";
+import { tools, resolveTool } from "./tools.js";
+
+const server = new StdioJsonRpcServer();
+
+server.register("ping", async () => ({ ok: true }));
+
+server.register("tools/list", async () => ({
+  tools: tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    outputSchema: tool.outputSchema,
+  })),
+}));
+
+server.register("tools/call", async (params) => {
+  const payload = (params ?? {}) as { name?: unknown; arguments?: unknown };
+  if (typeof payload.name !== "string") {
+    throw new Error("Tool name is required and must be a string");
+  }
+  const tool = resolveTool(payload.name);
+  if (!tool) {
+    throw new Error(`Tool ${payload.name} is not available`);
+  }
+  const args =
+    payload.arguments && typeof payload.arguments === "object"
+      ? (payload.arguments as Record<string, unknown>)
+      : {};
+  const result = await tool.handler(args);
+  return { content: result };
+});
+
+server.start();

package/src/lawApi.ts

@@ -0,0 +1,62 @@
+import { fetch } from "undici";
+import { cache } from "./cache.js";
+import { config } from "./config.js";
+import { LawData, LawSearchResponse } from "./types.js";
+
+const withTimeout = async <T>(promise: Promise<T>, ms: number) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+  try {
+    return await promise;
+  } finally {
+    clearTimeout(timer);
+  }
+};
+
+const request = async <T>(url: string) => {
+  const res = await withTimeout(
+    fetch(url, {
+      headers: {
+        "User-Agent": config.userAgent,
+        Accept: "application/json",
+      },
+    }),
+    config.httpTimeoutMs
+  );
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Request failed ${res.status}: ${body}`);
+  }
+
+  const data = (await res.json()) as T;
+  return data;
+};
+
+export const fetchLawData = async (
+  lawId: string,
+  revisionDate?: string
+): Promise<LawData> => {
+  const cacheKey = `law:${lawId}:${revisionDate || "latest"}`;
+  const cached = cache.get(cacheKey) as LawData | undefined;
+  if (cached) return cached;
+
+  const base = config.apiBase.endsWith("/")
+    ? config.apiBase
+    : `${config.apiBase}/`;
+  const url = new URL(`lawdata/${encodeURIComponent(lawId)}`, base);
+  if (revisionDate) url.searchParams.set("revision", revisionDate);
+  const data = await request<LawData>(url.toString());
+  cache.set(cacheKey, data, config.cacheTtlSeconds);
+  return data;
+};
+
+export const searchLaws = async (
+  keyword: string
+): Promise<LawSearchResponse> => {
+  const base = config.apiBase.endsWith("/")
+    ? config.apiBase
+    : `${config.apiBase}/`;
+  const url = new URL(`lawsearch/${encodeURIComponent(keyword)}`, base);
+  return request<LawSearchResponse>(url.toString());
+};