ynosis-agent-mcp 0.1.0 → 0.2.1

package/README.md

@@ -32,4 +32,26 @@ Ynosis Agent API 用の **MCP（stdio）**。Cursor など Node がある環境
 
 接続先の既定は `https://ynosis.jp`（リダイレクトを追います）。
 
-手順の詳細: <https://ynosis.jp/notes/usage-037>
+## 施設登録フロー（Python MCP と同一）
+
+```
+find_existing_facility → update_facility（既存・認定・タグ不足時も編集依頼）
+                      → resolve_place_candidates → prepare_facility_for_register → register_facility（新規）
+誤登録整理: remediate_duplicate_facility（正規へ依頼 + withdraw）
+```
+
+主要ツール: `find_existing_facility`, `prepare_facility_for_register`, `resolve_place_candidates`, `withdraw_facility`, `remediate_duplicate_facility`, `get_tag_options`
+
+## 運営: npm 公開
+
+リポジトリ内手順: [docs/agent/publishing.md](../../docs/agent/publishing.md#npmynosis-agent-mcp)
+
+```bash
+cd packages/ynosis-agent-mcp
+npm install && npm test
+npm publish --access public
+```
+
+公開前に Python パッケージ（`ynosis-agent`）との MCP パリティを確認: `.cursor/rules/ynosis-agent-mcp-parity.mdc`
+
+手順の詳細（利用者向け）: <https://ynosis.jp/notes/usage-037>

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "ynosis-agent-mcp",
-  "version": "0.1.0",
+  "version": "0.2.1",
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
   "description": "MCP stdio server for the Ynosis Agent API (facilities and spring analyses)",
   "type": "module",
   "bin": {
@@ -23,6 +26,8 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "kuroshiro": "^1.2.0",
+    "kuroshiro-analyzer-kuromoji": "^1.1.0",
     "zod": "^3.24.2"
   }
 }

package/src/client.mjs

@@ -101,6 +101,32 @@ export class AgentApiClient {
     return res.json;
   }
 
+  async findExistingFacility(name, prefecture = null, options = {}) {
+    const { findExistingFacility: findExisting } = await import("./facility_match.mjs");
+    return findExisting(this, name, prefecture, options);
+  }
+
+  async withdrawFacility(facilityId) {
+    const res = await this.request("POST", `/api/agent/facilities/${facilityId}/withdraw`);
+    return res.json;
+  }
+
+  async remediateDuplicateFacility(duplicateId, { canonicalId = null, dryRun = false } = {}) {
+    const { remediateDuplicateFacility: remediate } = await import("./facility_remediate.mjs");
+    return remediate(this, duplicateId, { canonicalId, dryRun });
+  }
+
+  async prepareFacilityPayload(payload, { place = null, maxResults = 5 } = {}) {
+    const { filterValidTags, resolvePlaceForPayload } = await import("./facility_prepare.mjs");
+    const prepared = { ...payload };
+    if (prepared.tags) prepared.tags = filterValidTags(prepared.tags);
+    const { payload: out, status, detail } = await resolvePlaceForPayload(prepared, {
+      place,
+      maxResults,
+    });
+    return { payload: out, place_status: status, detail };
+  }
+
   async registerFacilitiesBatch(facilities, { continueOnError = true } = {}) {
     const results = [];
     let created = 0;

package/src/csv_import.mjs

@@ -0,0 +1,54 @@
+/** 調査 CSV → FacilityCreate（Python ynosis_agent.csv_import と同期）。 */
+
+const STATUS_MAP = {
+  営業中: "active",
+  休業: "dormant",
+  閉業: "closed",
+  不明: "unknown",
+};
+
+function splitTags(raw) {
+  if (!raw?.trim()) return [];
+  return raw
+    .replace(/，/g, ",")
+    .split(";")
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+function buildNotes(row) {
+  const parts = [];
+  for (const key of ["湧出タイプ", "利用形態", "備考", "情報源"]) {
+    const val = (row[key] || "").trim();
+    if (val) parts.push(key === "備考" ? val : `${key}: ${val}`);
+  }
+  return parts.length ? parts.join("\n") : null;
+}
+
+function facilityName(row) {
+  const base = (row["施設名"] || "").trim();
+  const bath = (row["浴場名"] || "").trim();
+  if (base && bath) return `${base} ${bath}`;
+  return base || bath;
+}
+
+export function rowToFacilityPayload(row) {
+  const name = facilityName(row);
+  if (!name) throw new Error("施設名・浴場名のいずれかが必要です");
+
+  const prefecture = (row["都道府県"] || "").trim() || null;
+  const onsenName = (row["温泉地名"] || "").trim() || null;
+  const statusRaw = (row["営業状況(営業中/休業/閉業/不明)"] || row["営業状況"] || "").trim();
+  const status = STATUS_MAP[statusRaw] || (statusRaw ? "unknown" : "active");
+
+  const payload = {
+    name,
+    prefecture,
+    onsen_name: onsenName,
+    status_operational: status,
+    tags: splitTags(row["タグ(;区切り)"] || row["タグ"]),
+  };
+  const notes = buildNotes(row);
+  if (notes) payload.notes = notes;
+  return payload;
+}

package/src/facility_match.mjs

@@ -0,0 +1,142 @@
+/** 施設名類似度・既存照合（Python ynosis_agent.facility_match と同期）。 */
+
+import { toRomajiHepburn } from "./kuroshiro_romaji.mjs";
+import { sequenceRatio } from "./sequence_ratio.mjs";
+
+export const NEARBY_RADIUS_METERS = 50;
+export const NAME_SIMILARITY_HIGH = 0.8;
+export const NAME_SIMILARITY_LOW_WITH_LOCATION_HINT = 0.5;
+export const MATCH_SCORE_MIN = 85;
+
+export async function normalizeFacilityName(name) {
+  let text = String(name || "").normalize("NFKC");
+  text = text.replace(/[\s・･\-‐‑–—_/]+/g, "");
+  text = text.replace(/[（(][^）)]*[）)]/g, "");
+  text = text.replace(/(温泉|旅館|ホテル)$/, "");
+  if (!text) return "";
+  return toRomajiHepburn(text);
+}
+
+export async function nameSimilarity(a, b) {
+  const normA = await normalizeFacilityName(a);
+  const normB = await normalizeFacilityName(b);
+  if (!normA || !normB) return 0;
+  return sequenceRatio(normA, normB);
+}
+
+export function haversineDistanceMeters(lat1, lng1, lat2, lng2) {
+  const r = 6371000;
+  const phi1 = (lat1 * Math.PI) / 180;
+  const phi2 = (lat2 * Math.PI) / 180;
+  const dPhi = ((lat2 - lat1) * Math.PI) / 180;
+  const dLambda = ((lng2 - lng1) * Math.PI) / 180;
+  const a =
+    Math.sin(dPhi / 2) ** 2 +
+    Math.cos(phi1) * Math.cos(phi2) * Math.sin(dLambda / 2) ** 2;
+  return 2 * r * Math.asin(Math.sqrt(a));
+}
+
+export function facilitySearchQueries(name) {
+  const clean = String(name || "").trim();
+  if (!clean) return [];
+  const queries = [clean];
+  const noParen = clean.replace(/[（(].*?[）)]/g, "").trim();
+  if (noParen && !queries.includes(noParen)) queries.push(noParen);
+  return queries;
+}
+
+export async function scoreFacilityItem(candidateName, item) {
+  const dbName = item?.name || "";
+  let score = await nameSimilarity(candidateName, dbName);
+  for (const alias of item?.aliases || []) {
+    const aliasName = typeof alias === "object" ? alias?.name : alias;
+    if (aliasName) score = Math.max(score, await nameSimilarity(candidateName, String(aliasName)));
+  }
+  if (score >= 0.95) return 100;
+  if (score >= NAME_SIMILARITY_HIGH) return 90;
+  if (score >= NAME_SIMILARITY_LOW_WITH_LOCATION_HINT) return 85;
+  return 0;
+}
+
+async function scoreWithLocation(compareNames, item, lat, lng) {
+  let base = 0;
+  for (const cn of compareNames) {
+    base = Math.max(base, await scoreFacilityItem(cn, item));
+  }
+  if (base >= MATCH_SCORE_MIN) return base;
+  if (lat == null || lng == null) return base;
+  const itemLat = item?.lat;
+  const itemLng = item?.lng;
+  if (itemLat == null || itemLng == null) return base;
+  const distance = haversineDistanceMeters(lat, lng, Number(itemLat), Number(itemLng));
+  if (distance > NEARBY_RADIUS_METERS) return base;
+  let sim = 0;
+  for (const cn of compareNames) {
+    sim = Math.max(sim, await nameSimilarity(cn, item?.name || ""));
+  }
+  if (sim >= NAME_SIMILARITY_LOW_WITH_LOCATION_HINT) return Math.max(base, 85);
+  return base;
+}
+
+export async function findExistingFacility(
+  client,
+  name,
+  prefecture = null,
+  {
+    compareNames = null,
+    queries = null,
+    lat = null,
+    lng = null,
+    searchLimit = 30,
+  } = {}
+) {
+  const primary = String(name || "").trim();
+  if (!primary) return null;
+
+  const names = compareNames ? [...compareNames] : [primary];
+  if (!names.includes(primary)) names.unshift(primary);
+
+  const searchQs = [];
+  if (queries) {
+    for (const q of queries) {
+      const s = String(q || "").trim();
+      if (s && !searchQs.includes(s)) searchQs.push(s);
+    }
+  }
+  for (const cn of names) {
+    for (const q of facilitySearchQueries(cn)) {
+      if (!searchQs.includes(q)) searchQs.push(q);
+    }
+  }
+
+  let bestScore = 0;
+  let bestItem = null;
+  let bestSim = 0;
+
+  for (const q of searchQs) {
+    const params = { q, limit: searchLimit };
+    if (prefecture) params.prefecture = prefecture;
+    let res;
+    try {
+      res = await client.searchFacilities(params);
+    } catch {
+      continue;
+    }
+    for (const item of res.items || []) {
+      if (prefecture && (item.prefecture || "") !== prefecture) continue;
+      const sc = await scoreWithLocation(names, item, lat, lng);
+      let sim = 0;
+      for (const cn of names) {
+        sim = Math.max(sim, await nameSimilarity(cn, item.name || ""));
+      }
+      if (sc > bestScore) {
+        bestScore = sc;
+        bestItem = item;
+        bestSim = sim;
+      }
+    }
+  }
+
+  if (bestScore < MATCH_SCORE_MIN || !bestItem) return null;
+  return { facility: bestItem, match_score: bestScore, name_similarity: bestSim };
+}

package/src/facility_prepare.mjs

@@ -0,0 +1,153 @@
+/** 施設登録前 payload 整形（Python ynosis_agent.facility_prepare と同期）。 */
+
+import { FACILITY_TAG_OPTIONS } from "./client.mjs";
+import {
+  attachPlaceToPayload,
+  buildPlaceQuery,
+  pickPlaceCandidate,
+  placeFieldsFromCandidate,
+  resolvePlaceCandidates,
+} from "./places.mjs";
+
+export const WATER_TREATMENT_FIELDS = ["added_water", "added_heat", "circulation", "disinfection"];
+const TERNARY_STATES = new Set(["yes", "no", "unknown"]);
+
+export function filterValidTags(tags) {
+  if (!tags?.length) return [];
+  const allowed = new Set(FACILITY_TAG_OPTIONS);
+  const out = [];
+  for (const tag of tags) {
+    const t = String(tag || "").trim();
+    if (t && allowed.has(t) && !out.includes(t)) out.push(t);
+  }
+  return out;
+}
+
+export function pickWaterTreatmentFields(payload) {
+  const out = {};
+  for (const key of WATER_TREATMENT_FIELDS) {
+    const val = payload?.[key];
+    if (val == null) continue;
+    const s = String(val).trim().toLowerCase();
+    if (TERNARY_STATES.has(s)) out[key] = s;
+  }
+  return out;
+}
+
+export function mergeFacilityUpdates(existing, proposed, { mergeTags = true } = {}) {
+  const updates = {};
+
+  for (const key of ["hours", "price", "price_detail", "area", "address", "onsen_name", "notes"]) {
+    const val = proposed?.[key];
+    if (val != null && String(val).trim() && existing?.[key] !== val) updates[key] = val;
+  }
+
+  for (const [key, val] of Object.entries(pickWaterTreatmentFields(proposed))) {
+    if (existing?.[key] !== val) updates[key] = val;
+  }
+
+  const certs = [...(existing?.certifications || [])];
+  const newCerts = proposed?.certifications;
+  if (Array.isArray(newCerts)) {
+    const mergedCerts = [...certs];
+    let changed = false;
+    for (const c of newCerts) {
+      if (c && !mergedCerts.includes(c)) {
+        mergedCerts.push(c);
+        changed = true;
+      }
+    }
+    if (changed) updates.certifications = mergedCerts;
+  }
+
+  const propUrls = proposed?.certification_urls;
+  if (propUrls && typeof propUrls === "object") {
+    const urls = { ...(existing?.certification_urls || {}) };
+    let urlChanged = false;
+    for (const [cert, url] of Object.entries(propUrls)) {
+      if (url && urls[cert] !== url) {
+        urls[cert] = url;
+        urlChanged = true;
+      }
+    }
+    if (urlChanged) updates.certification_urls = urls;
+  }
+
+  if (mergeTags) {
+    const newTags = filterValidTags(proposed?.tags);
+    if (newTags.length) {
+      const merged = [...(existing?.tags || [])];
+      let changed = false;
+      for (const t of newTags) {
+        if (!merged.includes(t)) {
+          merged.push(t);
+          changed = true;
+        }
+      }
+      if (changed) updates.tags = merged;
+    }
+  }
+
+  return Object.keys(updates).length ? updates : null;
+}
+
+export async function resolvePlaceForPayload(payload, { place = null, maxResults = 5 } = {}) {
+  if (place) {
+    return { payload: attachPlaceToPayload(payload, place), status: "attached_given", detail: place };
+  }
+  if (payload?.lat != null && payload?.lng != null) {
+    return { payload, status: "skipped_has_location", detail: null };
+  }
+
+  const name = String(payload?.name || "").trim();
+  const prefecture = String(payload?.prefecture || "").trim();
+  const query = buildPlaceQuery({
+    name,
+    prefecture: prefecture || undefined,
+    address: payload?.address,
+    onsen_name: payload?.onsen_name,
+  });
+
+  let candidates;
+  try {
+    candidates = await resolvePlaceCandidates(query, { maxResults });
+  } catch (e) {
+    return { payload, status: "places_error", detail: e instanceof Error ? e.message : String(e) };
+  }
+
+  const picked = pickPlaceCandidate(name, prefecture, candidates);
+  if (picked) {
+    return {
+      payload: attachPlaceToPayload(payload, picked),
+      status: "attached_picked",
+      detail: picked,
+    };
+  }
+  return { payload, status: "needs_llm", detail: candidates };
+}
+
+export async function resolvePlaceUpdatesForFacility(facility, { maxResults = 5 } = {}) {
+  if (facility?.lat != null && facility?.lng != null) {
+    return { updates: null, status: "skipped_has_location", detail: null };
+  }
+
+  const name = String(facility?.name || "").trim();
+  const prefecture = String(facility?.prefecture || "").trim();
+  const query = buildPlaceQuery({
+    name,
+    prefecture: prefecture || undefined,
+    address: facility?.address,
+    onsen_name: facility?.onsen_name,
+  });
+
+  let candidates;
+  try {
+    candidates = await resolvePlaceCandidates(query, { maxResults });
+  } catch (e) {
+    return { updates: null, status: "places_error", detail: e instanceof Error ? e.message : String(e) };
+  }
+
+  const picked = pickPlaceCandidate(name, prefecture, candidates);
+  if (!picked) return { updates: null, status: "needs_llm", detail: candidates };
+  return { updates: placeFieldsFromCandidate(picked), status: "attached_picked", detail: picked };
+}

package/src/facility_remediate.mjs

@@ -0,0 +1,102 @@
+/** Agent 重複誤登録の整理（Python ynosis_agent.facility_remediate と同期）。 */
+
+import { MATCH_SCORE_MIN, facilitySearchQueries, scoreFacilityItem } from "./facility_match.mjs";
+import { mergeFacilityUpdates } from "./facility_prepare.mjs";
+
+function appendNote(existing, line) {
+  const base = String(existing || "").trim();
+  if (base.includes(line)) return base;
+  return base ? `${base}\n${line}` : line;
+}
+
+export async function findCanonicalFacility(client, duplicate, { searchLimit = 30 } = {}) {
+  const dupId = Number(duplicate.id);
+  const name = String(duplicate.name || "").trim();
+  const prefecture = duplicate.prefecture;
+  if (!name) return null;
+
+  let bestScore = 0;
+  let bestItem = null;
+  const queries = facilitySearchQueries(name);
+
+  for (const q of queries) {
+    const params = { q, limit: searchLimit };
+    if (prefecture) params.prefecture = prefecture;
+    let res;
+    try {
+      res = await client.searchFacilities(params);
+    } catch {
+      continue;
+    }
+    for (const item of res.items || []) {
+      if (Number(item.id) === dupId) continue;
+      if (prefecture && (item.prefecture || "") !== prefecture) continue;
+      const sc = await scoreFacilityItem(name, item);
+      if (sc > bestScore) {
+        bestScore = sc;
+        bestItem = item;
+      }
+    }
+  }
+
+  if (bestScore < MATCH_SCORE_MIN || !bestItem) return null;
+  return bestItem;
+}
+
+export async function remediateDuplicateFacility(
+  client,
+  duplicateId,
+  { canonicalId = null, dryRun = false } = {}
+) {
+  const duplicate = await client.getFacility(duplicateId);
+  if (duplicate.is_agent_approved) {
+    return { ok: false, error: "承認済みのため取り下げ不可", duplicate_id: duplicateId };
+  }
+
+  let canonical = canonicalId != null ? await client.getFacility(canonicalId) : await findCanonicalFacility(client, duplicate);
+  if (!canonical) {
+    return {
+      ok: false,
+      action: "no_canonical",
+      duplicate_id: duplicateId,
+      duplicate_name: duplicate.name,
+    };
+  }
+
+  const canonId = Number(canonical.id);
+  canonical = await client.getFacility(canonId);
+  const marker =
+    `[Agent重複整理] 未承認ID ${duplicateId}「${duplicate.name}」は` +
+    ` 当施設（ID ${canonId}）と同一の誤登録。Agent 側で取り下げ${dryRun ? "予定" : "済み"}。`;
+  const proposed = { ...duplicate, notes: appendNote(canonical.notes, marker) };
+  const updates = mergeFacilityUpdates(canonical, proposed) || {};
+  if (proposed.notes !== canonical.notes) updates.notes = proposed.notes;
+
+  const result = {
+    ok: true,
+    action: "remediate",
+    duplicate_id: duplicateId,
+    duplicate_name: duplicate.name,
+    canonical_id: canonId,
+    canonical_name: canonical.name,
+    updates,
+    dry_run: dryRun,
+  };
+
+  if (dryRun) return result;
+
+  let editRequestId = null;
+  if (!Object.keys(updates).length) {
+    result.warning = "正規施設への追記差分なし（認定・タグは既に付与済みの可能性）";
+  } else {
+    const resp = await client.updateFacility(canonId, updates);
+    editRequestId = resp.edit_request_id;
+    if (!editRequestId) {
+      result.warning = "編集依頼が作成されなかった（差分なし扱い）";
+    }
+  }
+  const withdraw = await client.withdrawFacility(duplicateId);
+  result.edit_request_id = editRequestId;
+  result.withdraw = withdraw;
+  return result;
+}

package/src/kuroshiro_romaji.mjs

@@ -0,0 +1,29 @@
+/** pykakasi hepburn と同等の romaji 化（kuroshiro + kuromoji）。 */
+
+let kuroshiroPromise = null;
+
+async function getKuroshiro() {
+  if (!kuroshiroPromise) {
+    kuroshiroPromise = (async () => {
+      const KuroshiroModule = await import("kuroshiro");
+      const KuromojiAnalyzerModule = await import("kuroshiro-analyzer-kuromoji");
+      const Kuroshiro =
+        KuroshiroModule.default?.default || KuroshiroModule.default || KuroshiroModule;
+      const KuromojiAnalyzer = KuromojiAnalyzerModule.default || KuromojiAnalyzerModule;
+      const instance = new Kuroshiro();
+      await instance.init(new KuromojiAnalyzer());
+      return instance;
+    })();
+  }
+  return kuroshiroPromise;
+}
+
+export async function toRomajiHepburn(text) {
+  const k = await getKuroshiro();
+  const romaji = await k.convert(text, {
+    to: "romaji",
+    mode: "normal",
+    romajiSystem: "hepburn",
+  });
+  return romaji.replace(/\s+/g, "").toLowerCase();
+}

package/src/places.mjs

@@ -0,0 +1,96 @@
+const TEXT_SEARCH_URL = "https://places.googleapis.com/v1/places:searchText";
+const FIELD_MASK = "places.id,places.displayName,places.formattedAddress,places.location";
+
+function resolveGoogleMapsApiKey() {
+  const key = process.env.GOOGLE_MAPS_API_KEY || "";
+  if (!key) {
+    throw new Error(
+      "GOOGLE_MAPS_API_KEY が未設定です。座標候補の取得には Google Maps API キーが必要です。"
+    );
+  }
+  return key;
+}
+
+export function buildPlaceQuery({ name, prefecture, address, onsen_name }) {
+  const parts = [String(name || "").trim()];
+  if (address?.trim()) parts.push(address.trim());
+  else if (prefecture?.trim()) parts.push(prefecture.trim());
+  if (onsen_name?.trim() && !parts.includes(onsen_name.trim())) parts.push(onsen_name.trim());
+  return parts.filter(Boolean).join(" ");
+}
+
+/** Text Search で候補を返す。採用は LLM / 人間が行う。 */
+export async function resolvePlaceCandidates(query, { maxResults = 5 } = {}) {
+  const q = String(query || "").trim();
+  if (!q) throw new Error("query が空です");
+  const key = resolveGoogleMapsApiKey();
+  const limit = Math.max(1, Math.min(maxResults, 10));
+
+  const res = await fetch(TEXT_SEARCH_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Goog-Api-Key": key,
+      "X-Goog-FieldMask": FIELD_MASK,
+    },
+    body: JSON.stringify({
+      textQuery: q,
+      languageCode: "ja",
+      regionCode: "JP",
+      maxResultCount: limit,
+    }),
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Places Text Search 失敗: HTTP ${res.status} ${text.slice(0, 200)}`);
+  }
+  const body = JSON.parse(text);
+  const places = body.places || [];
+  return places.slice(0, limit).map((place) => {
+    const loc = place.location || {};
+    return {
+      place_id: place.id,
+      name: place.displayName?.text,
+      formatted_address: place.formattedAddress,
+      lat: loc.latitude,
+      lng: loc.longitude,
+    };
+  });
+}
+
+function normName(s) {
+  return String(s || "")
+    .normalize("NFKC")
+    .replace(/\s+/g, "")
+    .toLowerCase();
+}
+
+export function placeFieldsFromCandidate(candidate) {
+  const out = {};
+  if (candidate?.place_id) out.place_id = candidate.place_id;
+  if (candidate?.lat != null) out.lat = candidate.lat;
+  if (candidate?.lng != null) out.lng = candidate.lng;
+  if (candidate?.formatted_address) out.address = candidate.formatted_address;
+  return out;
+}
+
+export function acceptPlaceCandidate(facilityName, prefecture, candidate) {
+  const addr = candidate?.formatted_address || "";
+  if (prefecture && !addr.includes(prefecture)) return false;
+  const fn = normName(facilityName);
+  const cn = normName(candidate?.name || "");
+  if (!fn || !cn) return false;
+  if (fn === cn) return true;
+  if (fn.includes(cn) || cn.includes(fn)) return Math.min(fn.length, cn.length) >= 4;
+  return false;
+}
+
+export function pickPlaceCandidate(facilityName, prefecture, candidates) {
+  if (!candidates?.length) return null;
+  const accepted = candidates.filter((c) => acceptPlaceCandidate(facilityName, prefecture, c));
+  return accepted.length === 1 ? accepted[0] : null;
+}
+
+export function attachPlaceToPayload(payload, candidate) {
+  return { ...payload, ...placeFieldsFromCandidate(candidate) };
+}

package/src/sequence_ratio.mjs

@@ -0,0 +1,20 @@
+/** difflib.SequenceMatcher.ratio 相当（2*M/T）。 */
+
+function lcsLength(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i = 1; i <= m; i += 1) {
+    for (let j = 1; j <= n; j += 1) {
+      if (a[i - 1] === b[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
+      else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+    }
+  }
+  return dp[m][n];
+}
+
+export function sequenceRatio(a, b) {
+  if (!a || !b) return 0;
+  const matches = lcsLength(a, b);
+  return (2 * matches) / (a.length + b.length);
+}

package/src/server.mjs

@@ -8,6 +8,8 @@ import {
   FACILITY_TAG_OPTIONS,
   prepareParsedForSave,
 } from "./client.mjs";
+import { rowToFacilityPayload } from "./csv_import.mjs";
+import { buildPlaceQuery, resolvePlaceCandidates } from "./places.mjs";
 
 function client() {
   return new AgentApiClient();
@@ -27,22 +29,139 @@ function textResult(text) {
 
 const server = new McpServer({
   name: "ynosis-agent",
-  version: "0.1.0",
+  version: "0.2.1",
   instructions:
     "Ynosis（温泉データベース）への施設・成分表登録・検索用ツール。" +
-    "検索は search_facilities / get_facility。" +
+    "新規施設登録前: find_existing_facility で重複確認 → 既存なら update_facility、" +
+    "新規のみ resolve_place_candidates → LLM が同一候補を選び prepare_facility_for_register → register_facility（推測禁止）。" +
+    "検索は search_facilities / get_facility / find_existing_facility。" +
     "施設登録は register_facilities_batch または register_facility。" +
     "成分表は手元 Vision なら get_parse_prompt → 手元 LLM → parse_transcript、" +
     "または analyze_source_image（Ynosis OCR）。" +
     "その後 register_source。新規源泉は image_path 必須。" +
     "OCR / サーバー抽出の parse は並列禁止。" +
-    "YNOSIS_AGENT_API_KEY（または AGENT_API_KEY）が必要。" +
-    "CLI は PyPI の ynosis-agent。CSV ファイル一括は CLI / Python MCP。",
+    "YNOSIS_AGENT_API_KEY と座標候補用 GOOGLE_MAPS_API_KEY が必要。" +
+    "CLI は PyPI の ynosis-agent。CSV ファイル一括は CLI / MCP。",
 });
 
 const dict = z.record(z.any());
 
-server.tool("register_facility", "施設を1件登録する（FacilityCreate 形式）。", { facility: dict }, async ({ facility }) => {
+server.tool(
+  "resolve_place_candidates",
+  "Google Places で座標候補を返す（最大5件）。採用は LLM が name/住所/県で同一施設か判断してから register_facility へ。env: GOOGLE_MAPS_API_KEY。",
+  {
+    query: z.string().optional(),
+    name: z.string().optional(),
+    prefecture: z.string().optional(),
+    address: z.string().optional(),
+    onsen_name: z.string().optional(),
+    max_results: z.number().optional(),
+  },
+  async ({ query, name, prefecture, address, onsen_name, max_results }) => {
+    try {
+      const q = query?.trim() || buildPlaceQuery({ name, prefecture, address, onsen_name });
+      const candidates = await resolvePlaceCandidates(q, { maxResults: max_results ?? 5 });
+      return textResult(
+        dump({
+          query: q,
+          candidates,
+          llm_hint:
+            "候補から同一施設を1件選び、register_facility の payload に lat/lng/place_id/address を含める。曖昧なら座標は付けない。",
+        })
+      );
+    } catch (e) {
+      return textResult(errText(e));
+    }
+  }
+);
+
+server.tool(
+  "prepare_facility_for_register",
+  "register 前にタグ整理・座標候補付与。place は LLM が resolve_place_candidates から選んだ1件。",
+  { facility: dict, place: dict.optional() },
+  async ({ facility, place }) => {
+    try {
+      return textResult(dump(await client().prepareFacilityPayload(facility, { place })));
+    } catch (e) {
+      return textResult(errText(e));
+    }
+  }
+);
+
+server.tool(
+  "withdraw_facility",
+  "未承認 Agent 新規施設を取り下げ（削除）。重複誤登録の整理用。",
+  { facility_id: z.number() },
+  async ({ facility_id }) => {
+    try {
+      return textResult(dump(await client().withdrawFacility(facility_id)));
+    } catch (e) {
+      return textResult(errText(e));
+    }
+  }
+);
+
+server.tool(
+  "remediate_duplicate_facility",
+  "正規施設へ編集依頼（備考に重複整理メモ）→ 誤登録を withdraw。",
+  {
+    duplicate_id: z.number(),
+    canonical_id: z.number().optional(),
+    dry_run: z.boolean().optional(),
+  },
+  async ({ duplicate_id, canonical_id, dry_run }) => {
+    try {
+      return textResult(
+        dump(
+          await client().remediateDuplicateFacility(duplicate_id, {
+            canonicalId: canonical_id ?? null,
+            dryRun: dry_run ?? false,
+          })
+        )
+      );
+    } catch (e) {
+      return textResult(errText(e));
+    }
+  }
+);
+
+server.tool(
+  "find_existing_facility",
+  "登録前に既存施設を照合（未承認含む）。ヒット時は update_facility、無ければ新規 register_facility。",
+  {
+    name: z.string(),
+    prefecture: z.string().optional(),
+    lat: z.number().optional(),
+    lng: z.number().optional(),
+    search_limit: z.number().optional(),
+  },
+  async ({ name, prefecture, lat, lng, search_limit }) => {
+    try {
+      const result = await client().findExistingFacility(name, prefecture, {
+        lat,
+        lng,
+        searchLimit: search_limit ?? 30,
+      });
+      if (!result) {
+        return textResult(
+          dump({
+            match: null,
+            hint: "既存施設なし。resolve_place_candidates の後 register_facility。",
+          })
+        );
+      }
+      return textResult(dump({ match: result }));
+    } catch (e) {
+      return textResult(errText(e));
+    }
+  }
+);
+
+server.tool(
+  "register_facility",
+  "施設を1件登録する（FacilityCreate 形式）。新規前に find_existing_facility → prepare_facility_for_register 推奨。",
+  { facility: dict },
+  async ({ facility }) => {
   try {
     return textResult(dump(await client().registerFacility(facility)));
   } catch (e) {
@@ -199,6 +318,19 @@ server.tool("get_tag_options", "登録可能な施設タグ一覧を返す。",
   textResult(dump({ tags: FACILITY_TAG_OPTIONS }))
 );
 
+server.tool(
+  "preview_csv_row",
+  "調査 CSV の1行を FacilityCreate にマッピングした結果をプレビューする。",
+  { row: z.record(z.string()) },
+  async ({ row }) => {
+    try {
+      return textResult(dump(rowToFacilityPayload(row)));
+    } catch (e) {
+      return textResult(errText(e));
+    }
+  }
+);
+
 server.tool(
   "upload_source_image",
   "成分表の証憑画像をアップロードする。",