@iola_adm/iola-cli 0.1.1 → 0.1.3

package/README.md

@@ -9,6 +9,55 @@ CLI для работы с открытыми данными городског
 - `https://apiiola.yasg.ru/api/v1`
 - `https://apiiola.yasg.ru/mcp`
 
+## Необходимые компоненты
+
+Проверьте Node.js и npm:
+
+```bash
+node --version
+npm --version
+```
+
+Нужен Node.js `18` или новее. Если Node.js не установлен:
+
+```bash
+# Windows
+winget install OpenJS.NodeJS.LTS
+
+# macOS
+brew install node
+
+# Linux, вариант через NodeSource
+curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+sudo apt-get install -y nodejs
+```
+
+Для локального AI-режима нужен Ollama. Проверка:
+
+```bash
+ollama --version
+```
+
+Установка Ollama:
+
+```bash
+# Windows
+winget install Ollama.Ollama
+
+# macOS
+brew install --cask ollama
+
+# Linux
+curl -fsSL https://ollama.com/install.sh | sh
+```
+
+Диагностика ПК и подбор локальной модели:
+
+```bash
+npx -y @iola_adm/iola-cli ai doctor
+npx -y @iola_adm/iola-cli ai setup ollama
+```
+
 ## Установка и запуск
 
 ```bash
@@ -25,14 +74,22 @@ iola help
 ## Команды
 
 ```bash
+iola ai doctor
+iola ai setup ollama
+iola health
 iola layers
 iola schools --limit 10
+iola schools get --inn 1215067180
 iola kindergartens --search "29"
+iola kindergartens get --inn 1215077421 --json
 iola search "лицей"
 iola mcp-info
 iola setup codex
 ```
 
+По умолчанию команды выводят компактную таблицу. Для полного ответа API
+используйте `--json`.
+
 ## Назначение
 
 Первый релиз CLI дает прямой терминальный доступ к открытым данным и командам

package/package.json

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

package/src/cli.js

@@ -1,9 +1,20 @@
+import { execFile } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
 const API_BASE_URL = process.env.IOLA_API_BASE_URL || "https://apiiola.yasg.ru/api/v1";
 const MCP_BASE_URL = process.env.IOLA_MCP_BASE_URL || "https://apiiola.yasg.ru";
+const CONFIG_DIR = path.join(os.homedir(), ".iola");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 
 const COMMANDS = new Map([
   ["help", showHelp],
   ["version", showVersion],
+  ["ai", handleAi],
+  ["health", checkHealth],
   ["layers", listLayers],
   ["schools", listSchools],
   ["kindergartens", listKindergartens],
@@ -27,11 +38,17 @@ async function showHelp() {
   console.log(`iola - CLI для открытых данных городского округа "Город Йошкар-Ола"
 
 Usage:
-  iola layers
-  iola schools [--limit 10] [--search TEXT]
-  iola kindergartens [--limit 10] [--search TEXT]
-  iola search TEXT [--limit 5]
-  iola mcp-info
+  iola ai doctor [--json]
+  iola ai setup
+  iola ai setup ollama [--yes] [--model MODEL]
+  iola health [--json]
+  iola layers [--json]
+  iola schools [--limit 10] [--search TEXT] [--json]
+  iola schools get --inn INN [--json]
+  iola kindergartens [--limit 10] [--search TEXT] [--json]
+  iola kindergartens get --inn INN [--json]
+  iola search TEXT [--limit 5] [--json]
+  iola mcp-info [--json]
   iola setup codex
   iola version
 
@@ -46,14 +63,185 @@ async function showVersion() {
   console.log(packageJson.default.version);
 }
 
-async function listLayers() {
+async function checkHealth(args) {
+  const options = parseOptions(args);
+  const health = await fetchJson(`${MCP_BASE_URL}/mcp-health`);
+
+  if (options.json) {
+    printJson(health);
+    return;
+  }
+
+  printKeyValue({
+    status: health.status,
+    server_version: health.server_version,
+    skill_version: health.skill_version,
+    mcp_endpoint: health.mcp_endpoint,
+  });
+}
+
+async function handleAi(args) {
+  const [subcommand = "help", ...rest] = args;
+
+  if (subcommand === "help") {
+    console.log(`AI-команды:
+  iola ai doctor [--json]
+  iola ai setup
+  iola ai setup ollama [--yes] [--model MODEL]
+
+Локальная настройка сохраняется в ${CONFIG_FILE}`);
+    return;
+  }
+
+  if (subcommand === "doctor") {
+    await aiDoctor(rest);
+    return;
+  }
+
+  if (subcommand === "setup") {
+    await aiSetup(rest);
+    return;
+  }
+
+  throw new Error(`Unknown AI command: ${subcommand}\nRun "iola ai help" to see available commands.`);
+}
+
+async function aiDoctor(args) {
+  const options = parseOptions(args);
+  const diagnostics = await getLocalDiagnostics();
+  const recommendation = recommendOllamaModel(diagnostics);
+
+  if (options.json) {
+    printJson({ ...diagnostics, recommendation });
+    return;
+  }
+
+  printDiagnostics(diagnostics, recommendation);
+}
+
+async function aiSetup(args) {
+  const [provider] = args;
+
+  if (!provider) {
+    const selected = await chooseAiProvider();
+    await aiSetup([selected]);
+    return;
+  }
+
+  if (provider === "ollama") {
+    await setupOllama(args.slice(1));
+    return;
+  }
+
+  if (provider === "openai" || provider === "openrouter") {
+    console.log(`Для ${provider} используйте переменную окружения ${provider === "openai" ? "OPENAI_API_KEY" : "OPENROUTER_API_KEY"}.`);
+    console.log("AI-запросы через API будут добавлены отдельной командой iola ai ask.");
+    return;
+  }
+
+  if (provider === "codex") {
+    await setupClient(["codex"]);
+    return;
+  }
+
+  throw new Error(`Unknown AI provider: ${provider}`);
+}
+
+async function chooseAiProvider() {
+  console.log("Выберите режим AI:");
+  console.log("1. Локальная модель через Ollama");
+  console.log("2. OpenAI API");
+  console.log("3. OpenRouter API");
+  console.log("4. Codex/MCP");
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = (await rl.question("Введите номер [1]: ")).trim() || "1";
+    return {
+      1: "ollama",
+      2: "openai",
+      3: "openrouter",
+      4: "codex",
+    }[answer] || "ollama";
+  } finally {
+    rl.close();
+  }
+}
+
+async function setupOllama(args) {
+  const options = parseOptions(args);
+  const diagnostics = await getLocalDiagnostics();
+  const recommendation = recommendOllamaModel(diagnostics);
+  const model = options.model || recommendation.model;
+
+  printDiagnostics(diagnostics, { ...recommendation, model });
+
+  if (!diagnostics.ollama.installed) {
+    console.log("");
+    console.log("Ollama не найден. Установите Ollama, затем повторите команду:");
+    console.log("  iola ai setup ollama");
+    console.log("");
+    console.log("Windows:");
+    console.log("  winget install Ollama.Ollama");
+    console.log("macOS:");
+    console.log("  brew install --cask ollama");
+    console.log("Linux:");
+    console.log("  curl -fsSL https://ollama.com/install.sh | sh");
+    return;
+  }
+
+  const shouldInstall = options.yes || (await confirm(`Установить модель ${model} через "ollama pull ${model}"? [Y/n] `));
+
+  if (shouldInstall) {
+    await runCommand("ollama", ["pull", model], { inherit: true });
+  }
+
+  await saveConfig({
+    ai: {
+      provider: "ollama",
+      model,
+      baseUrl: "http://127.0.0.1:11434",
+    },
+  });
+
+  console.log("");
+  console.log(`Готово. Локальный AI-профиль сохранен в ${CONFIG_FILE}`);
+}
+
+async function listLayers(args) {
+  const options = parseOptions(args);
   const info = await fetchJson(`${MCP_BASE_URL}/mcp-version`);
-  printJson(info.data_layers);
+
+  if (options.json) {
+    printJson(info.data_layers);
+    return;
+  }
+
+  printTable(info.data_layers, [
+    ["id", "ID"],
+    ["name", "Название"],
+    ["category", "Категория"],
+    ["status", "Статус"],
+  ]);
 }
 
-async function showMcpInfo() {
+async function showMcpInfo(args) {
+  const options = parseOptions(args);
   const info = await fetchJson(`${MCP_BASE_URL}/mcp-version`);
-  printJson(info);
+
+  if (options.json) {
+    printJson(info);
+    return;
+  }
+
+  printKeyValue({
+    server_name: info.server_name,
+    server_version: info.server_version,
+    skill_version: info.skill_version,
+    npm_package: info.npm_package,
+    mcp_endpoint: info.mcp_endpoint,
+    layers: info.data_layers.map((layer) => layer.id).join(", "),
+  });
 }
 
 async function listSchools(args) {
@@ -66,6 +254,12 @@ async function listKindergartens(args) {
 
 async function listDataset(dataset, args) {
   const options = parseOptions(args);
+
+  if (options._[0] === "get") {
+    await getDatasetItem(dataset, options);
+    return;
+  }
+
   const params = new URLSearchParams();
   params.set("limit", options.limit || "20");
   params.set("offset", options.offset || "0");
@@ -73,7 +267,34 @@ async function listDataset(dataset, args) {
   const data = await fetchJson(`${API_BASE_URL}/${dataset}?${params}`);
   const items = normalizeItems(data);
   const filtered = options.search ? filterItems(items, options.search) : items;
-  printJson(filtered.slice(0, Number(options.limit || 20)));
+  const limited = filtered.slice(0, Number(options.limit || 20));
+
+  if (options.json) {
+    printJson(limited);
+    return;
+  }
+
+  printDatasetTable(limited);
+}
+
+async function getDatasetItem(dataset, options) {
+  if (!options.inn) {
+    throw new Error(`INN is required. Example: iola ${dataset} get --inn 1215067180`);
+  }
+
+  const data = await fetchJson(`${API_BASE_URL}/${dataset}?limit=500&offset=0`);
+  const item = normalizeItems(data).find((entry) => String(entry.inn) === String(options.inn));
+
+  if (!item) {
+    throw new Error(`Record was not found in ${dataset}: inn=${options.inn}`);
+  }
+
+  if (options.json) {
+    printJson(item);
+    return;
+  }
+
+  printKeyValue(selectPublicSummary(item));
 }
 
 async function searchAll(args) {
@@ -95,7 +316,16 @@ async function searchAll(args) {
     kindergartens: filterItems(normalizeItems(kindergartens), query).slice(0, limit),
   };
 
-  printJson(result);
+  if (options.json) {
+    printJson(result);
+    return;
+  }
+
+  console.log("Школы");
+  printDatasetTable(result.schools);
+  console.log("");
+  console.log("Детские сады");
+  printDatasetTable(result.kindergartens);
 }
 
 async function setupClient(args) {
@@ -115,7 +345,9 @@ function parseOptions(args) {
 
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--limit" || arg === "--offset" || arg === "--search") {
+    if (arg === "--json" || arg === "--yes") {
+      result[arg.slice(2)] = true;
+    } else if (arg === "--limit" || arg === "--offset" || arg === "--search" || arg === "--inn") {
       result[arg.slice(2)] = args[index + 1];
       index += 1;
     } else {
@@ -147,6 +379,192 @@ function normalizeItems(payload) {
   return [];
 }
 
+function selectPublicSummary(item) {
+  return {
+    inn: item.inn,
+    name: item.fns_short_name || item.fns_full_name,
+    address: item.address || item.legal_address,
+    phone: item.phone,
+    email: item.email,
+    website: item.website,
+    head: item.fns_head_name,
+    license_number: item.license_number,
+    license_status: item.license_status,
+  };
+}
+
+async function getLocalDiagnostics() {
+  const [nvidia, windowsGpu, ollamaVersion] = await Promise.all([
+    getNvidiaGpu(),
+    process.platform === "win32" ? getWindowsGpu() : Promise.resolve(null),
+    getOllamaVersion(),
+  ]);
+  const gpu = nvidia || windowsGpu || { name: "-", vramGb: null, source: "not-detected" };
+
+  return {
+    os: `${os.type()} ${os.release()} (${process.arch})`,
+    cpu: os.cpus()?.[0]?.model || "-",
+    ramGb: roundGb(os.totalmem()),
+    gpu,
+    ollama: {
+      installed: Boolean(ollamaVersion),
+      version: ollamaVersion || "-",
+    },
+  };
+}
+
+async function getNvidiaGpu() {
+  try {
+    const { stdout } = await runCommand("nvidia-smi", [
+      "--query-gpu=name,memory.total",
+      "--format=csv,noheader,nounits",
+    ]);
+    const [line] = stdout.trim().split(/\r?\n/).filter(Boolean);
+
+    if (!line) {
+      return null;
+    }
+
+    const [name, memoryMb] = line.split(",").map((value) => value.trim());
+    return {
+      name,
+      vramGb: Math.round((Number(memoryMb) / 1024) * 10) / 10,
+      source: "nvidia-smi",
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function getWindowsGpu() {
+  try {
+    const command = [
+      "$gpu = Get-CimInstance Win32_VideoController |",
+      "Sort-Object AdapterRAM -Descending |",
+      "Select-Object -First 1 Name,AdapterRAM;",
+      "$gpu | ConvertTo-Json -Compress",
+    ].join(" ");
+    const { stdout } = await runCommand("powershell.exe", ["-NoProfile", "-Command", command]);
+    const parsed = JSON.parse(stdout.trim());
+
+    return {
+      name: parsed.Name || "-",
+      vramGb: parsed.AdapterRAM ? roundGb(Number(parsed.AdapterRAM)) : null,
+      source: "Win32_VideoController",
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function getOllamaVersion() {
+  try {
+    const { stdout } = await runCommand("ollama", ["--version"]);
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+function recommendOllamaModel(diagnostics) {
+  const ramGb = diagnostics.ramGb || 0;
+  const vramGb = diagnostics.gpu.vramGb || 0;
+
+  if (ramGb >= 32 && vramGb >= 8) {
+    return {
+      profile: "good",
+      model: "qwen3:8b",
+      reason: "достаточно RAM/VRAM для более качественной локальной модели.",
+    };
+  }
+
+  if (ramGb >= 16 && vramGb >= 4) {
+    return {
+      profile: "balanced",
+      model: "qwen3:4b",
+      reason: "баланс качества, скорости и памяти для работы с вопросами по данным.",
+    };
+  }
+
+  if (ramGb >= 12) {
+    return {
+      profile: "standard",
+      model: "llama3.2:3b",
+      reason: "достаточно оперативной памяти для компактной универсальной модели.",
+    };
+  }
+
+  return {
+    profile: "low",
+    model: "llama3.2:1b",
+    reason: "минимальная модель для слабого ПК или CPU-only режима.",
+  };
+}
+
+function printDiagnostics(diagnostics, recommendation) {
+  console.log("Диагностика системы");
+  printKeyValue({
+    os: diagnostics.os,
+    cpu: diagnostics.cpu,
+    ram: `${diagnostics.ramGb} GB`,
+    gpu: diagnostics.gpu.name,
+    vram: diagnostics.gpu.vramGb ? `${diagnostics.gpu.vramGb} GB` : "-",
+    ollama: diagnostics.ollama.installed ? diagnostics.ollama.version : "не установлен",
+  });
+  console.log("");
+  console.log("Рекомендация");
+  printKeyValue({
+    profile: recommendation.profile,
+    model: recommendation.model,
+    reason: recommendation.reason,
+    install: `ollama pull ${recommendation.model}`,
+  });
+}
+
+async function confirm(question) {
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = (await rl.question(question)).trim().toLocaleLowerCase("ru-RU");
+    return answer === "" || answer === "y" || answer === "yes" || answer === "д" || answer === "да";
+  } finally {
+    rl.close();
+  }
+}
+
+async function saveConfig(value) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(command, args, {
+      windowsHide: true,
+      maxBuffer: 1024 * 1024 * 5,
+    }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve({ stdout, stderr });
+    });
+
+    if (options.inherit) {
+      child.stdout?.pipe(process.stdout);
+      child.stderr?.pipe(process.stderr);
+    }
+  });
+}
+
+function roundGb(bytes) {
+  return Math.round((bytes / 1024 / 1024 / 1024) * 10) / 10;
+}
+
 async function fetchJson(url) {
   const response = await fetch(url, {
     headers: {
@@ -165,3 +583,79 @@ async function fetchJson(url) {
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
+
+function printDatasetTable(items) {
+  printTable(items.map(selectPublicSummary), [
+    ["inn", "ИНН"],
+    ["name", "Название"],
+    ["address", "Адрес"],
+    ["phone", "Телефон"],
+  ]);
+}
+
+function printKeyValue(value) {
+  const rows = Object.entries(value).map(([key, raw]) => ({
+    key,
+    value: raw == null || raw === "" ? "-" : String(raw),
+  }));
+
+  printTable(rows, [
+    ["key", "Поле"],
+    ["value", "Значение"],
+  ]);
+}
+
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    console.log("Нет данных.");
+    return;
+  }
+
+  const normalized = rows.map((row) =>
+    Object.fromEntries(
+      columns.map(([key]) => [key, formatCell(row[key])]),
+    ),
+  );
+  const widths = columns.map(([key, title]) =>
+    Math.min(
+      Math.max(
+        visibleLength(title),
+        ...normalized.map((row) => visibleLength(row[key])),
+      ),
+      52,
+    ),
+  );
+  const header = columns.map(([, title], index) => padCell(title, widths[index])).join("  ");
+  const divider = widths.map((width) => "-".repeat(width)).join("  ");
+
+  console.log(header);
+  console.log(divider);
+
+  for (const row of normalized) {
+    console.log(columns.map(([key], index) => padCell(truncateCell(row[key], widths[index]), widths[index])).join("  "));
+  }
+}
+
+function formatCell(value) {
+  if (value == null || value === "") {
+    return "-";
+  }
+
+  return String(value).replace(/\s+/g, " ").trim();
+}
+
+function truncateCell(value, width) {
+  if (visibleLength(value) <= width) {
+    return value;
+  }
+
+  return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+
+function padCell(value, width) {
+  return value + " ".repeat(Math.max(0, width - visibleLength(value)));
+}
+
+function visibleLength(value) {
+  return String(value).length;
+}