@iola_adm/iola-cli 0.1.71 → 0.1.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iola_adm/iola-cli",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "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 = [
@@ -5969,6 +5977,20 @@ async function aiAsk(args, context = {}) {
   const historyEnabled = !options.bare && !options["no-history"] && isFeatureEnabled("sqlite-history");
   const sessionId = historyEnabled && isFeatureEnabled("sessions") ? ensureSessionForAsk(options, providerConfig, question) : null;
   const history = context.history || (sessionId ? getSessionAiHistory(sessionId) : []);
+  const directAnswer = buildDirectDataAnswer(question, dataContext);
+  if (directAnswer) {
+    if (historyEnabled) {
+      recordAskHistory({ question, answer: directAnswer, providerConfig, dataContext, error: "", sessionId });
+      appendSessionExchange(sessionId, question, directAnswer, dataContext, "");
+    }
+    emitEvent(options, "answer", { length: directAnswer.length, sessionId, direct: true });
+    if (options.output) {
+      await assertPermission("writeFiles");
+      await writeFile(options.output, directAnswer, "utf8");
+    }
+    if (!options.quiet) console.log(directAnswer);
+    return directAnswer;
+  }
   const messages = await buildAiMessages(question, dataContext, history, options, config);
   let answer = "";
   let errorMessage = "";
@@ -6018,6 +6040,28 @@ async function aiAsk(args, context = {}) {
   return answer;
 }
 
+function buildDirectDataAnswer(question, dataContext) {
+  const normalized = question.toLocaleLowerCase("ru-RU");
+  if (!/(директор|руководител)/iu.test(normalized)) return "";
+  const terms = extractSearchTerms(question).filter((term) => !/^\d+$/.test(term));
+  if (terms.length < 2) return "";
+  const rows = [
+    ...dataContext.schools.map((item) => ({ layer: "schools", layerName: "школы", ...item })),
+    ...dataContext.kindergartens.map((item) => ({ layer: "kindergartens", layerName: "детские сады", ...item })),
+  ];
+  const matches = rows.filter((item) => {
+    const head = String(item.head || "").toLocaleLowerCase("ru-RU");
+    return terms.every((term) => head.includes(term));
+  });
+  if (matches.length !== 1) return "";
+  const item = matches[0];
+  return [
+    `${item.head} — руководитель ${item.name}.`,
+    item.address ? `Адрес: ${item.address}.` : "",
+    `Источник: слой ${item.layer}, ИНН ${item.inn || "-"}.`,
+  ].filter(Boolean).join("\n");
+}
+
 async function resolveUsableAiProfile(config, options = {}) {
   const explicit = Boolean(options.profile || options.provider);
   const providerConfig = resolveAiProfile(config, options);
@@ -6431,33 +6475,71 @@ 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`),
-    fetchJson(`${apiBaseUrl}/schools?limit=100&offset=0`),
-    fetchJson(`${apiBaseUrl}/kindergartens?limit=100&offset=0`),
-  ]);
   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)
-    : [];
+  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 || [],
+    layers,
     query: {
       text: question,
       terms: queryTerms,
       patterns,
     },
-    schools: schoolItems.map(selectPublicSummary),
-    kindergartens: kindergartenItems.map(selectPublicSummary),
+    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) {
+  const all = [];
+  for (let offset = 0; offset < maxItems; offset += limit) {
+    const separator = endpoint.includes("?") ? "&" : "?";
+    const payload = await fetchJson(`${endpoint}${separator}limit=${limit}&offset=${offset}`);
+    const items = normalizeItems(payload);
+    all.push(...items);
+    if (items.length < limit) break;
+  }
+  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"],
   };
 }
 
@@ -6481,7 +6563,13 @@ function shouldUseDataContext(question, options = {}) {
   if (/^(привет|здравствуй|здравствуйте|добрый день|доброе утро|добрый вечер|hi|hello|hey)[!.?\s]*$/iu.test(normalized)) return false;
   if (/^(спасибо|благодарю|ок|окей|понял|поняла|ясно|хорошо|да|нет)[!.?\s]*$/iu.test(normalized)) return false;
   if (normalized.length <= 24 && /^(как дела|что нового|ты тут|ты здесь|кто ты)[?.!\s]*$/iu.test(normalized)) return false;
-  return /\b(школ|сад|детсад|детский сад|лицей|гимнази|инн|адрес|телефон|почт|email|сайт|лиценз|руководител|директор|слой|слои|данн|отчет|отчёт|выгруз|csv|json|найди|покажи|список|карточк|организац|учрежден|йошкар|ола|петрова|строител|советск|первомайск)\b/iu.test(normalized);
+  const dataKeywords = [
+    "школ", "сад", "детсад", "детский сад", "лицей", "гимнази", "инн", "адрес", "телефон",
+    "почт", "email", "сайт", "лиценз", "руководител", "директор", "слой", "слои", "данн",
+    "отчет", "отчёт", "выгруз", "csv", "json", "найди", "покажи", "список", "карточк",
+    "организац", "учрежден", "йошкар", "ола", "петрова", "строител", "советск", "первомайск",
+  ];
+  return dataKeywords.some((keyword) => normalized.includes(keyword));
 }
 
 function extractSearchTerms(question) {
@@ -6491,7 +6579,13 @@ function extractSearchTerms(question) {
     .split(/\s+/)
     .map((term) => term.trim())
     .filter(Boolean)
-    .filter((term) => !["какие", "какая", "какой", "есть", "найди", "покажи", "контакты", "адрес", "телефон", "школы", "школа", "сад", "детский", "детские", "сады", "улица", "ул"].includes(term));
+    .filter((term) => ![
+      "в", "во", "на", "по", "и", "а", "ну", "так", "слушай", "скажи", "подскажи",
+      "какие", "какая", "какой", "каком", "какой", "есть", "найди", "покажи",
+      "контакты", "адрес", "телефон", "школы", "школа", "школе", "сад", "детский",
+      "детские", "сады", "улица", "ул", "директор", "руководитель",
+    ].includes(term))
+    .filter((term) => term.length > 2 || /^\d+$/.test(term));
 
   return normalized.length > 0 ? normalized : [question];
 }
@@ -6539,8 +6633,10 @@ function scoreItem(item, terms, patterns, layer) {
   const text = JSON.stringify(summary).toLocaleLowerCase("ru-RU");
   const name = String(summary.name || "").toLocaleLowerCase("ru-RU");
   const address = String(summary.address || "").toLocaleLowerCase("ru-RU");
+  const head = String(summary.head || "").toLocaleLowerCase("ru-RU");
   const generalTerms = terms.filter((term) => !/^\d+$/.test(term));
   let score = generalTerms.reduce((value, term) => value + (text.includes(term.toLocaleLowerCase("ru-RU")) ? 1 : 0), 0);
+  score += generalTerms.reduce((value, term) => value + (head.includes(term.toLocaleLowerCase("ru-RU")) ? 5 : 0), 0);
 
   for (const inn of patterns.inns) {
     if (String(summary.inn) === inn) {
@@ -7781,6 +7877,10 @@ 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.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: "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" } }) },
@@ -7798,6 +7898,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" },
@@ -7815,6 +7916,17 @@ function mcpPrompts() {
 }
 
 async function callMcpTool(name, args = {}) {
+  if (name === "layer.list") {
+    return Object.entries(DATASETS)
+      .map(([id, meta]) => layerSchema(id))
+      .filter((layer) => !args.category || layer.category === args.category);
+  }
+  if (name === "layer.schema") return layerSchema(args.layer);
+  if (name === "layer.query") return queryLayer(args.layer, args);
+  if (name === "layer.get") {
+    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 === "index.search") return searchDocs(args.query || "", Number(args.limit || 20));
   if (name === "report") {
     const output = args.output || `${args.name || "education-contacts"}.${args.format || "xlsx"}`;
@@ -7834,6 +7946,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);
@@ -8982,6 +9095,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;
 }