@iola_adm/iola-cli 0.1.2 → 0.1.4

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,6 +74,9 @@ iola help
 ## Команды
 
 ```bash
+iola banner
+iola ai doctor
+iola ai setup ollama
 iola health
 iola layers
 iola schools --limit 10

package/package.json

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

package/src/cli.js

@@ -1,9 +1,33 @@
+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 BANNER = `\x1b[38;5;45m┌────────────────────────────────────────────────────────────────────────────┐
+│\x1b[38;5;51m   ____ _     ___      ____  ____   ___  _____ _  _______                  \x1b[38;5;45m│
+│\x1b[38;5;51m  / ___| |   |_ _|    |  _ \\|  _ \\ / _ \\| ____| |/ /_   _|                 \x1b[38;5;45m│
+│\x1b[38;5;51m | |   | |    | |_____| |_) | |_) | | | |  _| | ' /  | |                   \x1b[38;5;45m│
+│\x1b[38;5;51m | |___| |___ | |_____|  __/|  _ <| |_| | |___| . \\  | |                   \x1b[38;5;45m│
+│\x1b[38;5;51m  \\____|_____|___|    |_|   |_| \\_\\\\___/|_____|_|\\_\\ |_|                   \x1b[38;5;45m│
+│                                                                            │
+│\x1b[38;5;213m                    Й О Ш К А Р - О Л Ы                                    \x1b[38;5;45m│
+│                                                                            │
+│\x1b[38;5;250m        открытые данные • MCP • локальный AI                               \x1b[38;5;45m│
+│                                                                            │
+│\x1b[38;5;82m        > iola help                                                         \x1b[38;5;45m│
+└────────────────────────────────────────────────────────────────────────────┘\x1b[0m`;
 
 const COMMANDS = new Map([
   ["help", showHelp],
   ["version", showVersion],
+  ["banner", showBanner],
+  ["ai", handleAi],
   ["health", checkHealth],
   ["layers", listLayers],
   ["schools", listSchools],
@@ -25,9 +49,14 @@ export async function main(argv) {
 }
 
 async function showHelp() {
+  showBanner();
   console.log(`iola - CLI для открытых данных городского округа "Город Йошкар-Ола"
 
 Usage:
+  iola banner
+  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]
@@ -45,6 +74,16 @@ Environment:
 `);
 }
 
+function showBanner() {
+  if (process.stdout.isTTY && process.env.NO_COLOR !== "1") {
+    console.log(BANNER);
+    return;
+  }
+
+  console.log("CLI-ПРОЕКТ ЙОШКАР-ОЛЫ");
+  console.log("открытые данные • MCP • локальный AI");
+}
+
 async function showVersion() {
   const packageJson = await import("../package.json", { with: { type: "json" } });
   console.log(packageJson.default.version);
@@ -67,6 +106,136 @@ async function checkHealth(args) {
   });
 }
 
+async function handleAi(args) {
+  const [subcommand = "help", ...rest] = args;
+
+  if (subcommand === "help") {
+    showBanner();
+    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) {
+    showBanner();
+    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`);
@@ -204,8 +373,8 @@ function parseOptions(args) {
 
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--json") {
-      result.json = true;
+    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;
@@ -252,6 +421,178 @@ function selectPublicSummary(item) {
   };
 }
 
+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: {