@iola_adm/iola-cli 0.1.72 → 0.1.74

package/README.md

@@ -129,6 +129,9 @@ iola version --check
 - subagents, skill bundles, layered settings, usage/budget accounting и trajectory export;
 - полноценный локальный MCP server по stdio/http: tools, resources и prompts;
 - MCP-мост для локальной модели: встроенный `iola-local` доступен как `mcp:iola-local:TOOL`;
+- вопросы по открытым данным сначала идут в публичный remote MCP `https://apiiola.yasg.ru/mcp`
+  через `layer_suggest`, `layer_query`, `layer_get` и `layer_answer_context`, а локальная БД/API
+  остаются fallback;
 - дополнительные stdio MCP-серверы можно добавить в `~/.iola/config.json` в раздел `mcp.servers`;
 - браузерный runtime через Playwright: чтение страниц, скриншоты, PDF, клики, ввод и eval;
 - управляемые локальные файловые операции с режимами `locked`, `read-only`, `workspace-write`, `full-access`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iola_adm/iola-cli",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "description": "CLI и AI-агент городского округа Йошкар-Ола.",
   "license": "MIT",
   "homepage": "https://github.com/adm-iola/iola-cli#readme",

package/skills/education/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: education
+description: Вопросы по образовательным учреждениям Йошкар-Олы: школы, детские сады, руководители, контакты, адреса и лицензии.
+---
+
+Используй MCP tools слоя данных, а не прямую догадку модели.
+
+Основные слои:
+
+- `schools` — муниципальные школы, лицеи и гимназии.
+- `kindergartens` — муниципальные детские сады.
+
+Для поиска используй:
+
+- `mcp:iola-local:layer.list` — список доступных слоев.
+- `mcp:iola-local:layer.schema` — схема слоя.
+- `mcp:iola-local:layer.query` — поиск по слою.
+- `mcp:iola-local:layer.get` — точная карточка записи.
+
+Если вопрос можно ответить точным совпадением по руководителю, ИНН, названию или адресу, отвечай только по найденной записи и указывай источник: слой, название и ИНН.
+
+Если совпадений нет или их несколько, прямо скажи, что данных недостаточно или нужно уточнение. Не выдумывай школы, детские сады, руководителей, адреса, телефоны, лицензии и сайты.

package/src/cli.js

@@ -180,7 +180,7 @@ const DEFAULT_AI_CONFIG = {
     suggestions: true,
   },
   skills: {
-    enabled: ["open-data", "reports", "local-model", "local-files", "browser-agent"],
+    enabled: ["education", "open-data", "reports", "local-model", "local-files", "browser-agent"],
   },
   daemon: {
     host: "127.0.0.1",
@@ -236,11 +236,19 @@ const AGENTS = {
 const DATASETS = {
   schools: {
     title: "Школы",
+    category: "Образование",
     endpoint: "schools",
+    aliases: ["школ", "лицей", "гимнази"],
+    searchFields: ["name", "address", "head", "inn"],
+    personFields: ["head"],
   },
   kindergartens: {
     title: "Детские сады",
+    category: "Образование",
     endpoint: "kindergartens",
+    aliases: ["сад", "детсад", "детский сад", "доу", "мбдоу"],
+    searchFields: ["name", "address", "head", "inn"],
+    personFields: ["head"],
   },
 };
 const SLASH_COMMANDS = [
@@ -6467,34 +6475,52 @@ function emitEvent(options, type, data) {
 
 async function buildDataContext(question) {
   await assertPermission("externalApi");
-  const apiBaseUrl = await getApiBaseUrl();
-  const mcpBaseUrl = await getMcpBaseUrl();
-  const [layers, schools, kindergartens] = await Promise.all([
-    fetchJson(`${mcpBaseUrl}/mcp-version`),
-    fetchAllApiItems(`${apiBaseUrl}/schools`),
-    fetchAllApiItems(`${apiBaseUrl}/kindergartens`),
-  ]);
   const queryTerms = extractSearchTerms(question);
   const patterns = extractStructuredPatterns(question);
-  const includeSchools = patterns.targetLayers.length === 0 || patterns.targetLayers.includes("schools");
-  const includeKindergartens = patterns.targetLayers.length === 0 || patterns.targetLayers.includes("kindergartens");
-  const schoolItems = includeSchools
-    ? findRelevantItems(normalizeItems(schools), queryTerms, patterns, "schools").slice(0, 8)
-    : [];
-  const kindergartenItems = includeKindergartens
-    ? findRelevantItems(normalizeItems(kindergartens), queryTerms, patterns, "kindergartens").slice(0, 8)
-    : [];
+  try {
+    const context = await callPublicMcpTool("layer_answer_context", { question, limit: 8 });
+    const layerMap = Object.fromEntries((context.results || []).map((result) => [result.layer?.id || result.layer, result.items || []]));
+    return {
+      source: "remote-mcp",
+      contract_version: context.contract_version,
+      layers: context.layers || [],
+      facts: context.facts || [],
+      sources: context.sources || [],
+      answer_guidance: context.answer_guidance || "",
+      query: {
+        text: question,
+        terms: queryTerms,
+        patterns,
+      },
+      schools: layerMap.schools || [],
+      kindergartens: layerMap.kindergartens || [],
+    };
+  } catch (error) {
+    const layers = await callMcpTool("layer.list", { category: "Образование" });
+    const targetLayerIds = resolveTargetLayerIds(patterns);
+    const layerResults = await Promise.all(targetLayerIds.map((layer) =>
+      callMcpTool("layer.query", { layer, query: question, terms: queryTerms, patterns, limit: 8 })));
+    const layerMap = Object.fromEntries(layerResults.map((result) => [result.layer, result.items || []]));
 
-  return {
-    layers: layers.data_layers || [],
-    query: {
-      text: question,
-      terms: queryTerms,
-      patterns,
-    },
-    schools: schoolItems.map(selectPublicSummary),
-    kindergartens: kindergartenItems.map(selectPublicSummary),
-  };
+    return {
+      source: "local-fallback",
+      fallback_error: error instanceof Error ? error.message : String(error),
+      layers,
+      query: {
+        text: question,
+        terms: queryTerms,
+        patterns,
+      },
+      schools: layerMap.schools || [],
+      kindergartens: layerMap.kindergartens || [],
+    };
+  }
+}
+
+function resolveTargetLayerIds(patterns = {}) {
+  const knownLayers = Object.keys(DATASETS);
+  if (patterns.targetLayers?.length) return patterns.targetLayers.filter((layer) => DATASETS[layer]);
+  return knownLayers;
 }
 
 async function fetchAllApiItems(endpoint, limit = 500, maxItems = 5000) {
@@ -6509,6 +6535,36 @@ async function fetchAllApiItems(endpoint, limit = 500, maxItems = 5000) {
   return all;
 }
 
+async function queryLayer(layer, args = {}) {
+  const meta = DATASETS[layer];
+  if (!meta) throw new Error(`Неизвестный слой: ${layer}`);
+  const endpoint = `${await getApiBaseUrl()}/${meta.endpoint}`;
+  const items = await fetchAllApiItems(endpoint);
+  const terms = args.terms || extractSearchTerms(args.query || "");
+  const patterns = args.patterns || extractStructuredPatterns(args.query || "");
+  const limit = Number(args.limit || 20);
+  return {
+    layer,
+    schema: layerSchema(layer),
+    items: findRelevantItems(normalizeItems(items), terms, patterns, layer).slice(0, limit).map(selectPublicSummary),
+  };
+}
+
+function layerSchema(layer) {
+  const meta = DATASETS[layer];
+  if (!meta) throw new Error(`Неизвестный слой: ${layer}`);
+  return {
+    id: layer,
+    title: meta.title,
+    category: meta.category,
+    endpoint: meta.endpoint,
+    aliases: meta.aliases || [],
+    searchFields: meta.searchFields || [],
+    personFields: meta.personFields || [],
+    sourceFields: ["layer", "name", "inn"],
+  };
+}
+
 function emptyDataContext(question) {
   return {
     enabled: false,
@@ -6844,6 +6900,7 @@ async function showMcpInfo(args) {
     server_name: info.server_name,
     server_version: info.server_version,
     skill_version: info.skill_version,
+    contract_version: info.contract_version || "-",
     npm_package: info.npm_package,
     mcp_endpoint: info.mcp_endpoint,
     layers: info.data_layers.map((layer) => layer.id).join(", "),
@@ -6894,9 +6951,9 @@ async function listDataset(dataset, args) {
 
   const data = options.local
       ? searchLocalRecords(options.search || options._.join(" ") || "", { dataset, limit: Number(options.limit || 20), fts: options.fts })
-    : normalizeItems(await fetchJsonMaybeCached(`${await getApiBaseUrl()}/${DATASETS[dataset].endpoint}?${params}`, options));
+    : await listDatasetViaRemoteMcp(dataset, options, params);
   const items = data;
-  const filtered = applyDatasetFilters(items, options);
+  const filtered = applyDatasetFilters(items, options.local ? options : { ...options, search: "" });
   const limited = filtered.slice(0, Number(options.limit || 20));
   const summarized = limited.map(selectPublicSummary);
   const projected = projectColumns(summarized, options.columns);
@@ -6918,13 +6975,34 @@ async function listDataset(dataset, args) {
   printDatasetTable(projected, options.columns);
 }
 
+async function listDatasetViaRemoteMcp(dataset, options, params) {
+  try {
+    const limit = Number(options.limit || 20);
+    const offset = Number(options.offset || 0);
+    const query = options.search || options._.join(" ") || "";
+    const result = await callPublicMcpTool("layer_query", {
+      layer: dataset,
+      query,
+      limit: offset + limit,
+    });
+    return normalizeItems(result.items || []).slice(offset, offset + limit);
+  } catch (error) {
+    if (options.debug) {
+      console.error(`remote MCP fallback to API: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return normalizeItems(await fetchJsonMaybeCached(`${await getApiBaseUrl()}/${DATASETS[dataset].endpoint}?${params}`, options));
+  }
+}
+
 async function getDatasetItem(dataset, options) {
   if (!options.inn) {
     throw new Error(`INN is required. Example: iola ${dataset} get --inn 1215067180`);
   }
 
-  const data = await fetchJson(`${await getApiBaseUrl()}/${DATASETS[dataset].endpoint}?limit=500&offset=0`);
-  const item = normalizeItems(data).find((entry) => String(entry.inn) === String(options.inn));
+  const result = options.local
+    ? { found: true, item: searchLocalRecords(options.inn, { dataset, limit: 1, fts: false })[0] }
+    : await callPublicMcpTool("layer_get", { layer: dataset, inn: options.inn });
+  const item = result?.item;
 
   if (!item) {
     throw new Error(`Record was not found in ${dataset}: inn=${options.inn}`);
@@ -6953,13 +7031,13 @@ async function searchAll(args) {
         searchLocalRecords(query, { dataset: "kindergartens", limit, fts: options.fts }),
       ]
     : await Promise.all([
-        fetchJsonMaybeCached(`${await getApiBaseUrl()}/schools?limit=100&offset=0`, options),
-        fetchJsonMaybeCached(`${await getApiBaseUrl()}/kindergartens?limit=100&offset=0`, options),
+        callPublicMcpTool("layer_query", { layer: "schools", query, limit }),
+        callPublicMcpTool("layer_query", { layer: "kindergartens", query, limit }),
       ]);
 
   const result = {
-    schools: projectColumns(filterItems(normalizeItems(schools), query).slice(0, limit).map(selectPublicSummary), options.columns),
-    kindergartens: projectColumns(filterItems(normalizeItems(kindergartens), query).slice(0, limit).map(selectPublicSummary), options.columns),
+    schools: projectColumns((options.local ? filterItems(normalizeItems(schools.items || schools), query) : normalizeItems(schools.items || schools)).slice(0, limit).map(selectPublicSummary), options.columns),
+    kindergartens: projectColumns((options.local ? filterItems(normalizeItems(kindergartens.items || kindergartens), query) : normalizeItems(kindergartens.items || kindergartens)).slice(0, limit).map(selectPublicSummary), options.columns),
   };
 
   if (options.json || options.format === "json") {
@@ -7843,6 +7921,12 @@ function mcpTools() {
   const schema = (properties = {}) => ({ type: "object", properties, additionalProperties: false });
   return [
     { name: "status", description: "Статус локальной БД, sync и активного AI-профиля.", inputSchema: schema() },
+    { name: "layer.list", description: "Список слоев данных и их схем.", inputSchema: schema({ category: { type: "string" } }) },
+    { name: "layer.schema", description: "Схема слоя данных.", inputSchema: schema({ layer: { type: "string" } }) },
+    { name: "layer.suggest", description: "Подобрать слой данных по вопросу пользователя через публичный MCP.", inputSchema: schema({ query: { type: "string" }, limit: { type: "number" } }) },
+    { name: "layer.query", description: "Поиск по слою данных через общий retrieval.", inputSchema: schema({ layer: { type: "string" }, query: { type: "string" }, terms: { type: "array" }, patterns: { type: "object" }, limit: { type: "number" } }) },
+    { name: "layer.get", description: "Получить запись слоя по ИНН или названию.", inputSchema: schema({ layer: { type: "string" }, query: { type: "string" }, inn: { type: "string" } }) },
+    { name: "layer.answer_context", description: "RAG-контекст с фактами и источниками через публичный MCP.", inputSchema: schema({ question: { type: "string" }, layer: { type: "string" }, limit: { type: "number" } }) },
     { name: "search", description: "Поиск по локальным открытым данным Йошкар-Олы.", inputSchema: schema({ query: { type: "string" }, dataset: { type: "string" }, limit: { type: "number" } }) },
     { name: "card", description: "Карточка объекта по названию или ИНН.", inputSchema: schema({ query: { type: "string" } }) },
     { name: "quality", description: "Проверки качества данных.", inputSchema: schema({ scope: { type: "string" } }) },
@@ -7860,6 +7944,7 @@ function mcpTools() {
 function mcpResources() {
   return [
     { uri: "iola://status", name: "Статус CLI", mimeType: "application/json" },
+    { uri: "iola://layers", name: "Слои данных", mimeType: "application/json" },
     { uri: "iola://sync", name: "Статус синхронизации", mimeType: "application/json" },
     { uri: "iola://settings", name: "Эффективные настройки", mimeType: "application/json" },
     { uri: "iola://skills", name: "Skills", mimeType: "application/json" },
@@ -7877,6 +7962,41 @@ function mcpPrompts() {
 }
 
 async function callMcpTool(name, args = {}) {
+  if (name === "layer.list") {
+    try {
+      const result = await callPublicMcpTool("layer_list", { category: args.category || undefined });
+      return result.items || result;
+    } catch {
+      return Object.entries(DATASETS)
+        .map(([id, meta]) => layerSchema(id))
+        .filter((layer) => !args.category || layer.category === args.category);
+    }
+  }
+  if (name === "layer.schema") {
+    try {
+      return await callPublicMcpTool("layer_schema", { layer: args.layer });
+    } catch {
+      return layerSchema(args.layer);
+    }
+  }
+  if (name === "layer.suggest") return callPublicMcpTool("layer_suggest", { query: args.query || "", limit: Number(args.limit || 5) });
+  if (name === "layer.query") {
+    try {
+      const result = await callPublicMcpTool("layer_query", { layer: args.layer, query: args.query || "", limit: Number(args.limit || 20) });
+      return { layer: result.layer?.id || args.layer, schema: result.layer, items: result.items || [] };
+    } catch {
+      return queryLayer(args.layer, args);
+    }
+  }
+  if (name === "layer.get") {
+    try {
+      return await callPublicMcpTool("layer_get", { layer: args.layer, query: args.query || "", inn: args.inn || "" });
+    } catch {
+      const result = await queryLayer(args.layer, { query: args.inn || args.query || "", terms: [args.inn || args.query || ""], limit: 1 });
+      return result.items[0] || null;
+    }
+  }
+  if (name === "layer.answer_context") return callPublicMcpTool("layer_answer_context", { question: args.question || "", layer: args.layer || "", limit: Number(args.limit || 5) });
   if (name === "index.search") return searchDocs(args.query || "", Number(args.limit || 20));
   if (name === "report") {
     const output = args.output || `${args.name || "education-contacts"}.${args.format || "xlsx"}`;
@@ -7896,6 +8016,7 @@ async function callMcpTool(name, args = {}) {
 
 async function readMcpResource(uri) {
   if (uri === "iola://status") return JSON.stringify({ db: getDbStatus(), sync: getSyncStatus() }, null, 2);
+  if (uri === "iola://layers") return JSON.stringify(Object.fromEntries(Object.keys(DATASETS).map((id) => [id, layerSchema(id)])), null, 2);
   if (uri === "iola://sync") return JSON.stringify(getSyncStatus(), null, 2);
   if (uri === "iola://settings") return JSON.stringify(await loadConfig(), null, 2);
   if (uri === "iola://skills") return JSON.stringify(listSkills(await loadConfig()), null, 2);
@@ -9044,6 +9165,9 @@ function sanitizeConfig(config) {
       }
     }
   }
+  if (Array.isArray(next.skills?.enabled) && next.skills.enabled.includes("open-data") && !next.skills.enabled.includes("education")) {
+    next.skills.enabled = ["education", ...next.skills.enabled];
+  }
   return next;
 }
 
@@ -9275,6 +9399,54 @@ async function fetchJson(url) {
   return response.json();
 }
 
+function parseJsonOrSse(text) {
+  const trimmed = String(text || "").trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(trimmed);
+  const dataLines = [];
+  for (const line of trimmed.split(/\r?\n/)) {
+    if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+  }
+  if (!dataLines.length) throw new Error(`Unexpected MCP response: ${trimmed.slice(0, 300)}`);
+  return JSON.parse(dataLines.join("\n"));
+}
+
+async function publicMcpRequest(method, params = undefined) {
+  const baseUrl = await getMcpBaseUrl();
+  const body = { jsonrpc: "2.0", id: 1, method };
+  if (params !== undefined) body.params = params;
+  const response = await fetch(`${baseUrl}/mcp`, {
+    method: "POST",
+    headers: {
+      accept: "application/json, text/event-stream",
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  if (!response.ok) {
+    throw new Error(`MCP ${method} failed: ${response.status} ${response.statusText}: ${text.slice(0, 300)}`);
+  }
+  const payload = parseJsonOrSse(text);
+  if (payload?.error) throw new Error(payload.error.message || JSON.stringify(payload.error));
+  return payload?.result;
+}
+
+async function callPublicMcpTool(name, args = {}) {
+  const result = await publicMcpRequest("tools/call", { name, arguments: args });
+  if (result?.structuredContent) return result.structuredContent;
+  if (result?.structured_content) return result.structured_content;
+  const text = result?.content?.find?.((item) => item.type === "text")?.text;
+  if (text) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return result;
+}
+
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }