law-mcp-server 0.1.0

package/src/mcp.ts

@@ -0,0 +1,87 @@
+import readline from "node:readline";
+
+type JsonRpcId = string | number | null;
+
+type JsonRpcRequest = {
+  jsonrpc: "2.0";
+  method: string;
+  id?: JsonRpcId;
+  params?: unknown;
+};
+
+type JsonRpcError = {
+  code: number;
+  message: string;
+};
+
+type RequestHandler = (params: unknown) => Promise<unknown> | unknown;
+
+export class StdioJsonRpcServer {
+  private handlers = new Map<string, RequestHandler>();
+
+  register(method: string, handler: RequestHandler) {
+    this.handlers.set(method, handler);
+  }
+
+  start() {
+    const rl = readline.createInterface({ input: process.stdin });
+    rl.on("line", async (line) => {
+      const message = this.parseMessage(line);
+      if (!message) return;
+
+      const { id, method, params } = message;
+      const handler = this.handlers.get(method);
+      if (!handler) {
+        if (id !== undefined) {
+          this.send({
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: "Method not found" },
+          });
+        }
+        return;
+      }
+      try {
+        const result = await handler(params ?? {});
+        if (id !== undefined) {
+          this.send({ jsonrpc: "2.0", id, result });
+        }
+      } catch (error) {
+        if (id !== undefined) {
+          const messageText =
+            error instanceof Error ? error.message : String(error);
+          this.send({
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32000, message: messageText },
+          });
+        }
+      }
+    });
+  }
+
+  private parseMessage(line: string): JsonRpcRequest | null {
+    try {
+      const parsed = JSON.parse(line) as JsonRpcRequest;
+      if (
+        !parsed ||
+        parsed.jsonrpc !== "2.0" ||
+        typeof parsed.method !== "string"
+      ) {
+        return null;
+      }
+      return parsed;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  private send(payload: {
+    jsonrpc: "2.0";
+    id: JsonRpcId;
+    result?: unknown;
+    error?: JsonRpcError;
+  }) {
+    process.stdout.write(JSON.stringify(payload) + "\n");
+  }
+}

package/src/tools.ts

@@ -0,0 +1,162 @@
+import { fetchLawData, searchLaws } from "./lawApi.js";
+import { checkConsistency } from "./consistency.js";
+import { ConsistencyOutput } from "./types.js";
+
+type ToolContent = { type: string; text?: string; data?: unknown };
+type ToolHandler = (input: Record<string, unknown>) => Promise<ToolContent[]>;
+
+type Tool = {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  outputSchema?: Record<string, unknown>;
+  handler: ToolHandler;
+};
+
+const requireString = (value: unknown, field: string) => {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Field ${field} is required`);
+  }
+  return value.trim();
+};
+
+const requireArrayOfStrings = (value: unknown, field: string) => {
+  if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+    throw new Error(`Field ${field} must be an array of strings`);
+  }
+  return value as string[];
+};
+
+const fetchLaw: Tool = {
+  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: Tool = {
+  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: Tool = {
+  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: Tool = {
+  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 as Record<string, unknown>).revisions)
+      ? ((data as Record<string, unknown>).revisions as string[])
+      : [];
+    return [{ type: "json", data: { lawId, revisions } }];
+  },
+};
+
+const check: Tool = {
+  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: ConsistencyOutput = checkConsistency(documentText, laws);
+    return [{ type: "json", data: output }];
+  },
+};
+
+export const tools: Tool[] = [
+  fetchLaw,
+  search,
+  listRevisions,
+  check,
+  summarize,
+];
+
+export const resolveTool = (name: string) =>
+  tools.find((tool) => tool.name === name);

package/src/types.ts

@@ -0,0 +1,54 @@
+export type LawArticleParagraph = {
+  ParagraphTitle?: string;
+  ParagraphSentence?: string | string[];
+};
+
+export type LawArticle = {
+  ArticleNumber?: string;
+  ArticleTitle?: string;
+  Paragraph?: LawArticleParagraph | LawArticleParagraph[];
+};
+
+export type LawBody = {
+  MainProvision?: {
+    Article?: LawArticle | LawArticle[];
+  };
+};
+
+export type LawData = {
+  LawID: string;
+  LawName?: string;
+  LawBody?: LawBody;
+  ApplProvision?: unknown;
+  SupplProvision?: unknown;
+};
+
+export type LawSearchItem = {
+  LawID: string;
+  LawName?: string;
+  PromulgationDate?: string;
+};
+
+export type LawSearchResponse = {
+  numberOfHits?: number;
+  referencelaw?: LawSearchItem | LawSearchItem[];
+};
+
+export type ToolResult = {
+  contentType: string;
+  data: unknown;
+};
+
+export type ConsistencyFinding = {
+  segment: string;
+  status: "aligned" | "potential_mismatch" | "not_found";
+  lawId?: string;
+  articleNumber?: string;
+  lawSnippet?: string;
+  score?: number;
+};
+
+export type ConsistencyOutput = {
+  findings: ConsistencyFinding[];
+  matchedLawIds: string[];
+};

package/test/integration.test.ts

@@ -0,0 +1,75 @@
+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/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "rootDir": ".",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}