law-mcp-server 0.1.6 → 0.2.0

package/dist/src/cache.js

@@ -1,3 +1,4 @@
+const MAX_ENTRIES = 500;
 export class MemoryCache {
     store = new Map();
     get(key) {
@@ -11,8 +12,24 @@ export class MemoryCache {
         return entry.value;
     }
     set(key, value, ttlSeconds) {
+        if (this.store.size >= MAX_ENTRIES) {
+            this.evictExpired();
+        }
+        if (this.store.size >= MAX_ENTRIES) {
+            const oldest = this.store.keys().next().value;
+            if (oldest !== undefined)
+                this.store.delete(oldest);
+        }
         const expiresAt = Date.now() + ttlSeconds * 1000;
         this.store.set(key, { value, expiresAt });
     }
+    evictExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.store) {
+            if (now > entry.expiresAt) {
+                this.store.delete(key);
+            }
+        }
+    }
 }
 export const cache = new MemoryCache();

package/dist/src/config.js

@@ -1,3 +1,8 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+export const name = pkg.name;
+export const version = pkg.version;
 const toNumber = (value, fallback) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : fallback;
@@ -6,5 +11,5 @@ export const config = {
     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",
+    userAgent: `${pkg.name}/${pkg.version}`,
 };

package/dist/src/index.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { StdioJsonRpcServer } from "./mcp.js";
-import { tools, resolveTool } from "./tools.js";
+import { tools, resolveTool, usageInstructions } from "./tools.js";
+import { name, version } from "./config.js";
 const server = new StdioJsonRpcServer();
-const serverInfo = { name: "law-mcp-server", version: "0.1.5" };
+const serverInfo = { name, version };
 server.register("initialize", async (params) => {
     const payload = (params ?? {});
     const protocolVersion = typeof payload.protocolVersion === "string"
@@ -11,21 +12,19 @@ server.register("initialize", async (params) => {
     return {
         protocolVersion,
         serverInfo,
+        instructions: usageInstructions,
         capabilities: {
-            tools: {
-                list: true,
-                call: true,
-            },
+            tools: {},
         },
     };
 });
-server.register("ping", async () => ({ ok: true }));
+server.register("notifications/initialized", async () => { });
+server.register("ping", async () => ({}));
 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) => {
@@ -40,7 +39,16 @@ server.register("tools/call", async (params) => {
     const args = payload.arguments && typeof payload.arguments === "object"
         ? payload.arguments
         : {};
-    const result = await tool.handler(args);
-    return { content: result };
+    try {
+        const result = await tool.handler(args);
+        return { content: result };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        };
+    }
 });
 server.start();

package/dist/src/lawApi.js

@@ -1,29 +1,37 @@
 import { fetch } from "undici";
 import { cache } from "./cache.js";
 import { config } from "./config.js";
-const withTimeout = async (promise, ms) => {
+class HttpError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`Request failed ${status}: ${body}`);
+        this.status = status;
+        this.body = body;
+    }
+}
+const request = async (url, context) => {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), ms);
+    const timer = setTimeout(() => controller.abort(), config.httpTimeoutMs);
+    let res;
     try {
-        return await promise;
+        res = await fetch(url, {
+            headers: {
+                "User-Agent": config.userAgent,
+                Accept: "application/json",
+            },
+            signal: controller.signal,
+        });
     }
     finally {
         clearTimeout(timer);
     }
-};
-const request = async (url, context) => {
-    const res = await withTimeout(fetch(url, {
-        headers: {
-            "User-Agent": config.userAgent,
-            Accept: "application/json",
-        },
-    }), config.httpTimeoutMs);
     if (!res.ok) {
         const body = await res.text();
         if (res.status === 404 && context?.lawId) {
             throw new Error(`Law not found for lawId "${context.lawId}". Use the official LawID (e.g., 平成十五年法律第五十七号 => H15HO57). Upstream: ${body}`);
         }
-        throw new Error(`Request failed ${res.status}: ${body}`);
+        throw new HttpError(res.status, body);
     }
     const data = (await res.json());
     return data;
@@ -44,25 +52,37 @@ export const fetchLawData = async (lawId, revisionDate) => {
     return data;
 };
 export const searchLaws = async (keyword) => {
+    const cacheKey = `search:${keyword}`;
+    const cached = cache.get(cacheKey);
+    if (cached)
+        return cached;
     const base = config.apiBase.endsWith("/")
         ? config.apiBase
         : `${config.apiBase}/`;
     const queryUrl = new URL(`lawsearch`, base);
     queryUrl.searchParams.set("keyword", keyword);
+    const attempts = [];
     try {
-        return await request(queryUrl.toString());
+        const data = await request(queryUrl.toString());
+        cache.set(cacheKey, data, config.cacheTtlSeconds);
+        return data;
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes("404")) {
-            // Some deployments expect the keyword in the path; retry once
-            const pathUrl = new URL(`lawsearch/${encodeURIComponent(keyword)}`, base);
-            try {
-                return await request(pathUrl.toString());
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                throw new Error(`Law search failed for keyword "${keyword}". Tried query and path styles. Upstream: ${msg}`);
+        if (error instanceof HttpError) {
+            attempts.push(`query style (${queryUrl.toString()}): ${error.status} ${error.body}`);
+            if (error.status === 404) {
+                const pathUrl = new URL(`lawsearch/${encodeURIComponent(keyword)}`, base);
+                try {
+                    const data = await request(pathUrl.toString());
+                    cache.set(cacheKey, data, config.cacheTtlSeconds);
+                    return data;
+                }
+                catch (err) {
+                    if (err instanceof HttpError) {
+                        attempts.push(`path style (${pathUrl.toString()}): ${err.status} ${err.body}`);
+                    }
+                    throw new Error(`Law search failed for keyword "${keyword}". Attempts: ${attempts.join(" | ")}. Ensure LAW_API_BASE is reachable and keyword is valid.`);
+                }
             }
         }
         throw error;

package/dist/src/tools.js

@@ -1,5 +1,6 @@
 import { fetchLawData, searchLaws } from "./lawApi.js";
 import { checkConsistency } from "./consistency.js";
+export const usageInstructions = `Usage guidelines:\n\n- To find laws by Japanese name/keyword, call search_laws first. It returns canonical e-Gov LawID values (e.g., 個人情報保護法 -> H15HO57).\n- Always pass the canonical LawID to fetch_law and check_consistency (lawIds). Do not pass the Japanese title string.\n- fetch_law accepts optional revisionDate when you need a specific revision.\n- check_consistency requires at least one LawID in lawIds. Use search_laws to discover the IDs before calling.\n- summarize_law can take an optional articles array of article numbers to limit the summary.`;
 const requireString = (value, field) => {
     if (typeof value !== "string" || value.trim().length === 0) {
         throw new Error(`Field ${field} is required`);
@@ -14,7 +15,7 @@ const requireArrayOfStrings = (value, field) => {
 };
 const fetchLaw = {
     name: "fetch_law",
-    description: "Fetch a law by LawID and optional revision date",
+    description: "Fetch a law by canonical e-Gov LawID (e.g., H15HO57) and optional revision date. Use search_laws to look up the LawID first.",
     inputSchema: {
         type: "object",
         properties: {
@@ -27,12 +28,12 @@ const fetchLaw = {
         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 }];
+        return [{ type: "text", text: JSON.stringify(data, null, 2) }];
     },
 };
 const search = {
     name: "search_laws",
-    description: "Search laws by keyword",
+    description: "Search laws by Japanese keyword/name and return canonical LawID values for use with other tools.",
     inputSchema: {
         type: "object",
         properties: {
@@ -43,7 +44,7 @@ const search = {
     handler: async (input) => {
         const keyword = requireString(input.keyword, "keyword");
         const results = await searchLaws(keyword);
-        return [{ type: "json", data: results }];
+        return [{ type: "text", text: JSON.stringify(results, null, 2) }];
     },
 };
 const summarize = {
@@ -72,42 +73,33 @@ const summarize = {
             ? articles.filter((article) => article.ArticleNumber &&
                 articlesFilter.includes(article.ArticleNumber))
             : articles;
+        const toArray = (v) => !v ? [] : Array.isArray(v) ? v : [v];
         const body = filtered
-            .map((article) => `${article.ArticleNumber || ""} ${article.ArticleTitle || ""}`.trim())
             .slice(0, 10)
-            .join("\n");
+            .map((article) => {
+            const heading = `${article.ArticleNumber || ""} ${article.ArticleTitle || ""}`.trim();
+            const paragraphs = toArray(article.Paragraph)
+                .map((p) => {
+                const sentences = toArray(p
+                    .ParagraphSentence);
+                return sentences.join("");
+            })
+                .filter(Boolean)
+                .join("\n");
+            return [heading, paragraphs].filter(Boolean).join("\n");
+        })
+            .join("\n\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",
+    description: "Check a document against one or more laws (lawIds must be canonical LawIDs from search_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"],
     },
@@ -121,13 +113,12 @@ const check = {
         }
         const laws = await Promise.all(lawIds.map((lawId) => fetchLawData(lawId)));
         const output = checkConsistency(documentText, laws);
-        return [{ type: "json", data: output }];
+        return [{ type: "text", text: JSON.stringify(output, null, 2) }];
     },
 };
 export const tools = [
     fetchLaw,
     search,
-    listRevisions,
     check,
     summarize,
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "law-mcp-server",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "type": "module",
   "description": "MCP server for e-Gov law API consistency checks",
   "files": [
@@ -16,14 +16,13 @@
   "scripts": {
     "build": "tsc",
     "prepare": "npm run build",
-    "start": "node dist/index.js",
+    "start": "node dist/src/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": {
-    "stripe": "^20.3.1",
     "undici": "^6.13.0"
   },
   "devDependencies": {