@iola_adm/iola-cli 0.1.14 → 0.1.17

package/README.md

@@ -99,6 +99,26 @@ iola features enable api-cache
 iola mcp status
 iola mcp list
 iola mcp install codex
+iola cache status
+iola cache warm
+iola cache clear
+iola sync
+iola sync status
+iola diff schools
+iola search "Петрова" --local
+iola search "Петрова" --local --fts
+iola card "школа 29"
+iola quality
+iola quality missing-phones
+iola data schools --where address=Петрова --save schools-petrova
+iola views
+iola view schools-petrova --format csv --output schools-petrova.csv
+iola views delete schools-petrova
+iola report missing-phones
+iola privacy
+iola backup create
+iola alias add petrova "data schools --where address=Петрова --columns name,address,phone"
+iola run "выгрузи школы на Петрова в csv"
 iola config get
 iola config set api.baseUrl https://apiiola.yasg.ru/api/v1
 iola config reset
@@ -107,6 +127,8 @@ iola version --check
 iola ask "Найди школу 29"
 iola ask "Найди школу 29" --profile codex --events --output answer.txt
 iola ask "Найди школу 29" --schema json --no-history
+iola ask "выгрузи школы на Петрова в csv" --profile local --tools --reasoning verify
+iola data schools --format csv --output schools.csv
 iola data schools --limit 10
 iola data kindergartens --search "29"
 iola data schools --where address=Петрова --columns name,address,phone
@@ -350,6 +372,102 @@ iola ask "Найди школу 29" --schema json
 iola ask "Найди школу 29" --output answer.txt
 ```
 
+## Кеш, локальный поиск и выборки
+
+API-ответы можно кешировать локально:
+
+```bash
+iola cache status
+iola cache warm
+iola cache clear
+iola data schools --cache
+```
+
+Локальная синхронизация сохраняет открытые слои в SQLite и позволяет искать без
+повторного обращения к API:
+
+```bash
+iola sync
+iola sync status
+iola diff
+iola search "Петрова" --local
+iola search "школа Петрова" --local --fts
+iola data schools --local --search "лицей"
+```
+
+Сохраненные выборки:
+
+```bash
+iola data schools --where address=Петрова --columns name,address,phone --save schools-petrova
+iola views
+iola view schools-petrova
+iola view schools-petrova --format csv --output schools-petrova.csv
+iola views delete schools-petrova
+```
+
+Отчеты, backup и алиасы:
+
+```bash
+iola report schools-summary
+iola report education-contacts
+iola report missing-phones
+iola report licenses
+iola privacy
+iola backup create
+iola alias add petrova "data schools --where address=Петрова --columns name,address,phone"
+iola petrova
+iola run "выгрузи школы на Петрова в csv"
+```
+
+## Локальный tool-agent для слабых моделей
+
+Для локального профиля Ollama доступен режим `--tools`. Он сделан специально
+для маленьких моделей, которые хуже отвечают свободным текстом, но могут быть
+полезны как планировщик действий.
+
+В этом режиме CLI не доверяет модели напрямую. Модель предлагает JSON-план,
+CLI валидирует список разрешенных tools и сам выполняет действия через
+проверенные локальные функции:
+
+- `search_local`
+- `get_card`
+- `export_data`
+- `run_report`
+- `save_view`
+
+Пример:
+
+```bash
+iola ask "выгрузи школы на Петрова в csv" --profile local --tools
+iola ask "найди детсады без телефона" --profile local --tools --reasoning verify
+```
+
+Режимы:
+
+```bash
+--reasoning fast    # один план
+--reasoning verify  # план с валидацией результата
+--reasoning vote    # несколько вариантов, выбирается валидный
+```
+
+OpenAI, OpenRouter и Codex работают как раньше. `--tools` применяется только
+к локальному Ollama-профилю, чтобы не менять поведение внешних провайдеров.
+
+Карточки, качество данных и изменения:
+
+```bash
+iola card schools 1215067180
+iola card "школа 29"
+iola quality
+iola quality schools
+iola quality missing-phones
+iola quality invalid-emails
+iola quality duplicate-inn
+iola sync status
+iola diff
+iola diff schools
+```
+
 ## Переменные окружения
 
 ```bash

package/package.json

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

package/src/cli.js

@@ -95,6 +95,18 @@ const COMMANDS = new Map([
   ["fork", forkSession],
   ["features", handleFeatures],
   ["mcp", handleMcp],
+  ["cache", handleCache],
+  ["sync", handleSync],
+  ["diff", handleDiff],
+  ["views", handleViews],
+  ["view", handleView],
+  ["card", handleCard],
+  ["quality", handleQuality],
+  ["report", handleReport],
+  ["privacy", handlePrivacy],
+  ["backup", handleBackup],
+  ["alias", handleAlias],
+  ["run", runNaturalLanguage],
   ["config", handleConfig],
   ["banner", showBanner],
   ["agent", startAgent],
@@ -122,6 +134,11 @@ export async function main(argv) {
   const handler = COMMANDS.get(command);
 
   if (!handler) {
+    const alias = getAlias(command);
+    if (alias) {
+      await main([...splitCommandLine(alias.command), ...args]);
+      return;
+    }
     throw new Error(`Unknown command: ${command}\nRun "iola help" to see available commands.`);
   }
 
@@ -147,12 +164,26 @@ Usage:
   iola fork SESSION_ID [TEXT]
   iola features list|enable|disable
   iola mcp list|status|install|remove
+  iola cache status|warm|clear
+  iola sync [--dataset schools|kindergartens]
+  iola sync status
+  iola diff [schools|kindergartens]
+  iola card schools 1215067180
+  iola card "школа 29"
+  iola quality [schools|kindergartens|missing-phones|invalid-emails|duplicate-inn]
+  iola views
+  iola view NAME [--format table|json|csv] [--output FILE]
+  iola report schools-summary|education-contacts|missing-phones|licenses
+  iola privacy
+  iola backup create
+  iola alias add NAME COMMAND
+  iola run "выгрузи школы на Петрова в csv"
   iola config get
   iola config set api.baseUrl URL
   iola config set api.mcpBaseUrl URL
   iola config reset
   iola update
-  iola ask TEXT [--profile NAME] [--model MODEL] [--output FILE] [--schema json|table] [--events] [--no-history]
+  iola ask TEXT [--profile NAME] [--model MODEL] [--tools] [--reasoning fast|verify|vote] [--output FILE] [--schema json|table] [--events] [--no-history]
   iola data LAYER [--limit 10] [--search TEXT] [--where FIELD=VALUE] [--columns a,b,c] [--format table|json|csv]
   iola ai ask TEXT [--provider ollama|openai|openrouter] [--model MODEL]
   iola ai context TEXT [--json]
@@ -291,6 +322,21 @@ async function handleAgentLine(line, state) {
     return false;
   }
 
+  if (command === "cache") {
+    await handleCache(args);
+    return false;
+  }
+
+  if (command === "sync") {
+    await handleSync(args);
+    return false;
+  }
+
+  if (command === "diff" || command === "card" || command === "quality" || command === "views" || command === "view" || command === "report" || command === "privacy" || command === "backup" || command === "alias" || command === "run") {
+    await COMMANDS.get(command)(args);
+    return false;
+  }
+
   if (command === "config") {
     await handleConfig(args.length > 0 ? args : ["get"]);
     return false;
@@ -376,6 +422,9 @@ async function handleAgentLine(line, state) {
     fork: ["fork", args],
     features: ["features", args],
     mcp: ["mcp", args],
+    cache: ["cache", args],
+    sync: ["sync", args],
+    diff: ["diff", args],
     config: ["config", args],
     layers: ["layers", args],
     data: ["data", args],
@@ -407,6 +456,12 @@ function printAgentHelp() {
   /resume SESSION_ID
   /features list
   /mcp status
+  /cache status
+  /sync
+  /diff
+  /card школа 29
+  /quality
+  /views
   /config get
   /config set api.baseUrl URL
   /layers
@@ -1046,6 +1101,196 @@ async function handleMcp(args) {
   throw new Error("Команды mcp: status, list, install codex, remove codex.");
 }
 
+async function handleCache(args) {
+  const [action = "status"] = args;
+  if (action === "status") {
+    printKeyValue(getCacheStatus());
+    return;
+  }
+  if (action === "clear") {
+    clearCache();
+    console.log("Кеш очищен.");
+    return;
+  }
+  if (action === "warm") {
+    const result = await warmCache();
+    printKeyValue(result);
+    return;
+  }
+  throw new Error("Команды cache: status, warm, clear.");
+}
+
+async function handleSync(args) {
+  const [action] = args;
+  if (action === "status") {
+    printTable(getSyncStatus(), [
+      ["dataset", "Слой"],
+      ["records", "Записей"],
+      ["last_sync", "Последний sync"],
+      ["status", "Статус"],
+    ]);
+    return;
+  }
+  const options = parseOptions(args);
+  const datasets = options.dataset ? [options.dataset] : Object.keys(DATASETS);
+  const rows = [];
+  for (const dataset of datasets) {
+    rows.push(await syncDataset(dataset));
+  }
+  printTable(rows, [
+    ["dataset", "Слой"],
+    ["records", "Записей"],
+    ["status", "Статус"],
+    ["message", "Сообщение"],
+  ]);
+}
+
+async function handleDiff(args) {
+  const [dataset] = args;
+  const rows = listSyncChanges(dataset);
+  printTable(rows, [
+    ["created_at", "Дата"],
+    ["dataset", "Слой"],
+    ["change_type", "Тип"],
+    ["record_key", "Ключ"],
+    ["summary", "Сводка"],
+  ]);
+}
+
+async function handleCard(args) {
+  await ensureLocalData();
+  const options = parseOptions(args);
+  const query = args.join(" ").trim();
+  if (!query) throw new Error('Пример: iola card "школа 29"');
+  const item = findCard(query);
+  if (!item) throw new Error(`Объект не найден: ${query}`);
+  if (options.json) {
+    printJson(item);
+    return;
+  }
+  printKeyValue(item);
+}
+
+async function handleQuality(args) {
+  const [scope = "all"] = args;
+  await ensureLocalData();
+  const rows = runQuality(scope);
+  printTable(rows, [
+    ["check", "Проверка"],
+    ["dataset", "Слой"],
+    ["count", "Кол-во"],
+    ["sample", "Пример"],
+  ]);
+}
+
+async function handleViews(args) {
+  const [action, name] = args;
+  if (action === "delete" || action === "remove") {
+    deleteSavedView(name);
+    console.log(`View удален: ${name}`);
+    return;
+  }
+  const rows = listSavedViews();
+  printTable(rows, [
+    ["name", "Имя"],
+    ["dataset", "Слой"],
+    ["created_at", "Создано"],
+  ]);
+}
+
+async function handleView(args) {
+  const [name, ...rest] = args;
+  if (!name) {
+    throw new Error("Имя view обязательно.");
+  }
+  const view = getSavedView(name);
+  const query = JSON.parse(view.query_json);
+  await listDataset(view.dataset, [...(query.args || []), ...rest]);
+}
+
+async function handleReport(args) {
+  const [name] = args;
+  await ensureLocalData();
+  if (name === "schools-summary") {
+    printTable(getLocalSummaryRows("schools"), [["metric", "Показатель"], ["value", "Значение"]]);
+    return;
+  }
+  if (name === "education-contacts") {
+    printDatasetTable(searchLocalRecords("", { dataset: "all", limit: 500 }), "name,address,phone,email,website");
+    return;
+  }
+  if (name === "missing-phones") {
+    printDatasetTable(searchLocalRecords("", { dataset: "all", limit: 500 }).filter((item) => !item.phone || item.phone === "-"));
+    return;
+  }
+  if (name === "licenses") {
+    printDatasetTable(searchLocalRecords("", { dataset: "all", limit: 500 }), "name,license_number,license_status");
+    return;
+  }
+  throw new Error("Отчеты: schools-summary, education-contacts, missing-phones, licenses.");
+}
+
+async function handlePrivacy() {
+  printKeyValue({
+    config: CONFIG_FILE,
+    secrets: SECRETS_FILE,
+    sqlite: DB_FILE,
+    api: await getApiBaseUrl(),
+    mcp: await getMcpBaseUrl(),
+    keys_in_sqlite: "no",
+    history_clear: "iola history clear",
+    db_reset: "iola db reset",
+    delete_openai_key: "iola ai key delete openai",
+  });
+}
+
+async function handleBackup(args) {
+  const [action = "create", fileArg] = args;
+  if (action !== "create") {
+    throw new Error("Пока доступно: iola backup create [FILE]");
+  }
+  const file = fileArg || path.join(CONFIG_DIR, `iola-backup-${new Date().toISOString().replace(/[:.]/g, "-")}.json`);
+  const payload = {
+    created_at: new Date().toISOString(),
+    config: await loadConfig(),
+    db: exportDbSnapshot(),
+  };
+  await writeFile(file, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  console.log(`Backup создан: ${file}`);
+}
+
+async function handleAlias(args) {
+  const [action, name, ...commandParts] = args;
+  if (action === "list" || !action) {
+    printTable(listAliases(), [["name", "Алиас"], ["command", "Команда"]]);
+    return;
+  }
+  if (action === "add") {
+    if (!name || commandParts.length === 0) {
+      throw new Error('Пример: iola alias add petrova "data schools --where address=Петрова"');
+    }
+    saveAlias(name, commandParts.join(" "));
+    console.log(`Алиас сохранен: ${name}`);
+    return;
+  }
+  if (action === "delete" || action === "remove") {
+    deleteAlias(name);
+    console.log(`Алиас удален: ${name}`);
+    return;
+  }
+  throw new Error("Команды alias: list, add NAME COMMAND, delete NAME.");
+}
+
+async function runNaturalLanguage(args) {
+  const text = args.join(" ").trim();
+  if (!text) {
+    throw new Error('Пример: iola run "выгрузи школы на Петрова в csv"');
+  }
+  const command = inferCommandFromText(text);
+  console.log(`> iola ${command.join(" ")}`);
+  await main(command);
+}
+
 async function aiDoctor(args) {
   const options = parseOptions(args);
   const diagnostics = await getLocalDiagnostics();
@@ -1600,6 +1845,39 @@ function initDatabase() {
         query_json TEXT NOT NULL,
         created_at TEXT NOT NULL DEFAULT (datetime('now'))
       );
+      CREATE TABLE IF NOT EXISTS local_records (
+        dataset TEXT NOT NULL,
+        record_key TEXT NOT NULL,
+        record_json TEXT NOT NULL,
+        searchable_text TEXT NOT NULL,
+        synced_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY(dataset, record_key)
+      );
+      CREATE INDEX IF NOT EXISTS idx_local_records_dataset ON local_records(dataset);
+      CREATE VIRTUAL TABLE IF NOT EXISTS local_records_fts USING fts5(dataset, record_key, searchable_text);
+      CREATE TABLE IF NOT EXISTS sync_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        dataset TEXT NOT NULL,
+        records INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        message TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE TABLE IF NOT EXISTS sync_changes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        dataset TEXT NOT NULL,
+        record_key TEXT NOT NULL,
+        change_type TEXT NOT NULL,
+        old_json TEXT,
+        new_json TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_sync_changes_dataset_created_at ON sync_changes(dataset, created_at DESC);
+      CREATE TABLE IF NOT EXISTS aliases (
+        name TEXT PRIMARY KEY,
+        command TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
     `);
     db.prepare(`
       INSERT INTO meta(key, value) VALUES ('schema_version', ?)
@@ -1626,12 +1904,16 @@ function getDbStatus() {
       const schema = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
       const history = db.prepare("SELECT COUNT(*) AS count FROM ask_history").get();
       const sessions = db.prepare("SELECT COUNT(*) AS count FROM sessions").get();
+      const local = db.prepare("SELECT COUNT(*) AS count FROM local_records").get();
+      const cache = db.prepare("SELECT COUNT(*) AS count FROM api_cache").get();
       return {
         status: "ok",
         file: DB_FILE,
         schema: schema?.value || "-",
         history: history?.count ?? 0,
         sessions: sessions?.count ?? 0,
+        local_records: local?.count ?? 0,
+        cache: cache?.count ?? 0,
       };
     } finally {
       db.close();
@@ -1862,6 +2144,399 @@ function setFeatureEnabled(name, enabled) {
   }
 }
 
+async function fetchJsonMaybeCached(url, options = {}) {
+  if (!options.cache && !isFeatureEnabled("api-cache")) {
+    return fetchJson(url);
+  }
+  const cached = getCachedResponse(url);
+  if (cached) {
+    return cached;
+  }
+  const payload = await fetchJson(url);
+  setCachedResponse(url, payload, 3600);
+  return payload;
+}
+
+function getCachedResponse(url) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const row = db.prepare("SELECT response_json, expires_at FROM api_cache WHERE key = ?").get(cacheKey(url));
+    if (!row) return null;
+    if (row.expires_at && new Date(row.expires_at) < new Date()) return null;
+    return JSON.parse(row.response_json);
+  } finally {
+    db.close();
+  }
+}
+
+function setCachedResponse(url, payload, ttlSeconds) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const expires = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+    db.prepare(`
+      INSERT INTO api_cache(key, url, response_json, expires_at, created_at)
+      VALUES (?, ?, ?, ?, datetime('now'))
+      ON CONFLICT(key) DO UPDATE SET response_json = excluded.response_json, expires_at = excluded.expires_at, created_at = excluded.created_at
+    `).run(cacheKey(url), url, JSON.stringify(payload), expires);
+  } finally {
+    db.close();
+  }
+}
+
+function cacheKey(url) {
+  return Buffer.from(url).toString("base64url");
+}
+
+function getCacheStatus() {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM api_cache").get();
+    return { status: "ok", entries: row?.count ?? 0 };
+  } finally {
+    db.close();
+  }
+}
+
+function clearCache() {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.exec("DELETE FROM api_cache");
+  } finally {
+    db.close();
+  }
+}
+
+async function warmCache() {
+  const urls = [
+    `${await getMcpBaseUrl()}/mcp-version`,
+    `${await getMcpBaseUrl()}/mcp-health`,
+    `${await getApiBaseUrl()}/schools?limit=100&offset=0`,
+    `${await getApiBaseUrl()}/kindergartens?limit=100&offset=0`,
+  ];
+  for (const url of urls) {
+    setCachedResponse(url, await fetchJson(url), 3600);
+  }
+  return { status: "ok", entries: urls.length };
+}
+
+async function syncDataset(dataset) {
+  if (!DATASETS[dataset]) {
+    throw new Error(`Неизвестный слой: ${dataset}`);
+  }
+  try {
+    const payload = await fetchJson(`${await getApiBaseUrl()}/${DATASETS[dataset].endpoint}?limit=500&offset=0`);
+    const items = normalizeItems(payload);
+    saveLocalRecords(dataset, items);
+    recordSyncRun(dataset, items.length, "ok", "");
+    return { dataset, records: items.length, status: "ok", message: "" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    recordSyncRun(dataset, 0, "error", message);
+    return { dataset, records: 0, status: "error", message };
+  }
+}
+
+function saveLocalRecords(dataset, items) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const oldRows = db.prepare("SELECT record_key, record_json FROM local_records WHERE dataset = ?").all(dataset);
+    const oldMap = new Map(oldRows.map((row) => [row.record_key, row.record_json]));
+    const newKeys = new Set();
+    db.prepare("DELETE FROM local_records WHERE dataset = ?").run(dataset);
+    db.prepare("DELETE FROM local_records_fts WHERE dataset = ?").run(dataset);
+    const insert = db.prepare("INSERT INTO local_records(dataset, record_key, record_json, searchable_text, synced_at) VALUES (?, ?, ?, ?, datetime('now'))");
+    const insertFts = db.prepare("INSERT INTO local_records_fts(dataset, record_key, searchable_text) VALUES (?, ?, ?)");
+    const insertChange = db.prepare("INSERT INTO sync_changes(dataset, record_key, change_type, old_json, new_json) VALUES (?, ?, ?, ?, ?)");
+    for (const item of items) {
+      const summary = selectPublicSummary(item);
+      const key = String(summary.inn || item.id || `${dataset}-${Math.random()}`);
+      newKeys.add(key);
+      const newJson = JSON.stringify(item);
+      const oldJson = oldMap.get(key);
+      if (!oldJson) insertChange.run(dataset, key, "added", null, newJson);
+      else if (oldJson !== newJson) insertChange.run(dataset, key, "changed", oldJson, newJson);
+      const text = JSON.stringify(summary).toLocaleLowerCase("ru-RU");
+      insert.run(dataset, key, newJson, text);
+      insertFts.run(dataset, key, text);
+    }
+    for (const [key, oldJson] of oldMap.entries()) {
+      if (!newKeys.has(key)) insertChange.run(dataset, key, "removed", oldJson, null);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+function recordSyncRun(dataset, records, status, message) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.prepare("INSERT INTO sync_runs(dataset, records, status, message) VALUES (?, ?, ?, ?)").run(dataset, records, status, message);
+  } finally {
+    db.close();
+  }
+}
+
+async function ensureLocalData() {
+  const status = getDbStatus();
+  if (Number(status.local_records || 0) === 0) {
+    await handleSync([]);
+  }
+}
+
+function searchLocalRecords(query, options = {}) {
+  initDatabase();
+  const db = openDatabase();
+  const dataset = options.dataset || "all";
+  const limit = Number(options.limit || 20);
+  try {
+    if (options.fts && query) {
+      const ftsQuery = query.split(/\s+/).filter(Boolean).map((term) => `"${term.replace(/"/g, "")}"`).join(" ");
+      const params = dataset === "all" ? [ftsQuery, limit] : [ftsQuery, dataset, limit];
+      const sql = dataset === "all"
+        ? "SELECT r.record_json FROM local_records_fts f JOIN local_records r ON r.dataset=f.dataset AND r.record_key=f.record_key WHERE local_records_fts MATCH ? LIMIT ?"
+        : "SELECT r.record_json FROM local_records_fts f JOIN local_records r ON r.dataset=f.dataset AND r.record_key=f.record_key WHERE local_records_fts MATCH ? AND f.dataset = ? LIMIT ?";
+      return db.prepare(sql).all(...params).map((row) => selectPublicSummary(JSON.parse(row.record_json)));
+    }
+    const params = [];
+    let sql = "SELECT dataset, record_json FROM local_records";
+    const where = [];
+    if (dataset !== "all") {
+      where.push("dataset = ?");
+      params.push(dataset);
+    }
+    if (query) {
+      where.push("searchable_text LIKE ?");
+      params.push(`%${query.toLocaleLowerCase("ru-RU")}%`);
+    }
+    if (where.length) sql += ` WHERE ${where.join(" AND ")}`;
+    sql += " ORDER BY dataset, record_key LIMIT ?";
+    params.push(limit);
+    return db.prepare(sql).all(...params).map((row) => selectPublicSummary(JSON.parse(row.record_json)));
+  } finally {
+    db.close();
+  }
+}
+
+function getSyncStatus() {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    return Object.keys(DATASETS).map((dataset) => {
+      const records = db.prepare("SELECT COUNT(*) AS count FROM local_records WHERE dataset = ?").get(dataset);
+      const run = db.prepare("SELECT status, created_at FROM sync_runs WHERE dataset = ? ORDER BY id DESC LIMIT 1").get(dataset);
+      return { dataset, records: records?.count || 0, last_sync: run?.created_at || "-", status: run?.status || "never" };
+    });
+  } finally {
+    db.close();
+  }
+}
+
+function listSyncChanges(dataset) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const rows = dataset
+      ? db.prepare("SELECT * FROM sync_changes WHERE dataset = ? ORDER BY id DESC LIMIT 50").all(dataset)
+      : db.prepare("SELECT * FROM sync_changes ORDER BY id DESC LIMIT 50").all();
+    return rows.map((row) => ({
+      ...row,
+      summary: summarizeChange(row),
+    }));
+  } finally {
+    db.close();
+  }
+}
+
+function summarizeChange(row) {
+  const payload = row.new_json || row.old_json;
+  if (!payload) return "-";
+  try {
+    const item = selectPublicSummary(JSON.parse(payload));
+    return item.name || item.inn || "-";
+  } catch {
+    return "-";
+  }
+}
+
+function findCard(query) {
+  const normalized = query.toLocaleLowerCase("ru-RU");
+  const dataset = normalized.includes("сад") ? "kindergartens" : normalized.includes("школ") || normalized.includes("лицей") ? "schools" : "all";
+  const inn = normalized.match(/\b\d{10,12}\b/)?.[0];
+  const number = normalized.match(/\b\d{1,3}\b/)?.[0];
+  const rows = searchLocalRecords(inn || number || query, { dataset, limit: 20, fts: false });
+  if (inn) return rows.find((row) => String(row.inn) === inn) || null;
+  if (number) return rows.find((row) => String(row.name || "").includes(`№ ${number}`) || String(row.name || "").includes(`№${number}`)) || rows[0] || null;
+  return rows[0] || null;
+}
+
+function runQuality(scope) {
+  const datasets = ["schools", "kindergartens"];
+  const rows = [];
+  for (const dataset of datasets) {
+    if (scope !== "all" && scope !== dataset && !scope.includes("-")) continue;
+    const records = searchLocalRecords("", { dataset, limit: 1000 });
+    const missingPhones = records.filter((item) => !item.phone || item.phone === "-");
+    const invalidEmails = records.filter((item) => item.email && !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(item.email));
+    const innCounts = new Map();
+    for (const item of records) innCounts.set(item.inn, (innCounts.get(item.inn) || 0) + 1);
+    const duplicateInn = records.filter((item) => item.inn && innCounts.get(item.inn) > 1);
+    if (scope === "all" || scope === dataset || scope === "missing-phones") rows.push({ check: "missing-phones", dataset, count: missingPhones.length, sample: missingPhones[0]?.name || "-" });
+    if (scope === "all" || scope === dataset || scope === "invalid-emails") rows.push({ check: "invalid-emails", dataset, count: invalidEmails.length, sample: invalidEmails[0]?.email || "-" });
+    if (scope === "all" || scope === dataset || scope === "duplicate-inn") rows.push({ check: "duplicate-inn", dataset, count: duplicateInn.length, sample: duplicateInn[0]?.inn || "-" });
+  }
+  return rows;
+}
+
+function saveView(name, dataset, args) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.prepare(`
+      INSERT INTO saved_views(name, dataset, query_json) VALUES (?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET dataset = excluded.dataset, query_json = excluded.query_json
+    `).run(name, dataset, JSON.stringify({ args }));
+  } finally {
+    db.close();
+  }
+}
+
+function listSavedViews() {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    return db.prepare("SELECT name, dataset, created_at FROM saved_views ORDER BY name").all();
+  } finally {
+    db.close();
+  }
+}
+
+function getSavedView(name) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    const row = db.prepare("SELECT * FROM saved_views WHERE name = ?").get(name);
+    if (!row) throw new Error(`View не найден: ${name}`);
+    return row;
+  } finally {
+    db.close();
+  }
+}
+
+function deleteSavedView(name) {
+  if (!name) {
+    throw new Error("Имя view обязательно.");
+  }
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.prepare("DELETE FROM saved_views WHERE name = ?").run(name);
+  } finally {
+    db.close();
+  }
+}
+
+function getLocalSummaryRows(dataset) {
+  const rows = searchLocalRecords("", { dataset, limit: 1000 });
+  return [
+    { metric: "records", value: rows.length },
+    { metric: "with_phone", value: rows.filter((row) => row.phone && row.phone !== "-").length },
+    { metric: "with_email", value: rows.filter((row) => row.email).length },
+    { metric: "with_website", value: rows.filter((row) => row.website).length },
+  ];
+}
+
+function exportDbSnapshot() {
+  initDatabase();
+  return {
+    db: getDbStatus(),
+    views: listSavedViews(),
+    aliases: listAliases(),
+    features: listFeatures(),
+    sessions: listSessions(100),
+    history: listHistory(100),
+  };
+}
+
+function listAliases() {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    return db.prepare("SELECT name, command FROM aliases ORDER BY name").all();
+  } finally {
+    db.close();
+  }
+}
+
+function getAlias(name) {
+  try {
+    initDatabase();
+    const db = openDatabase();
+    try {
+      return db.prepare("SELECT name, command FROM aliases WHERE name = ?").get(name);
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
+
+function saveAlias(name, command) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.prepare("INSERT INTO aliases(name, command) VALUES (?, ?) ON CONFLICT(name) DO UPDATE SET command = excluded.command").run(name, command);
+  } finally {
+    db.close();
+  }
+}
+
+function deleteAlias(name) {
+  initDatabase();
+  const db = openDatabase();
+  try {
+    db.prepare("DELETE FROM aliases WHERE name = ?").run(name);
+  } finally {
+    db.close();
+  }
+}
+
+function inferCommandFromText(text) {
+  const normalized = text.toLocaleLowerCase("ru-RU");
+  const dataset = normalized.includes("сад") ? "kindergartens" : "schools";
+  const command = ["data", dataset];
+  const street = normalized.match(/(?:на|по|улица|ул\.?)\s+([а-яёa-z-]+)/iu)?.[1];
+  if (street) command.push("--where", `address=${street}`);
+  if (normalized.includes("csv")) command.push("--format", "csv");
+  if (normalized.includes("json")) command.push("--format", "json");
+  const output = text.match(/(?:в файл|файл)\s+([^\s]+)/iu)?.[1];
+  if (output) command.push("--output", output);
+  return command;
+}
+
+async function outputData(value, options, format) {
+  const text = format === "csv" ? toCsv(value) : `${JSON.stringify(value, null, 2)}\n`;
+  if (options.output) {
+    await writeFile(options.output, text, "utf8");
+    console.log(`Файл сохранен: ${options.output}`);
+    return;
+  }
+  process.stdout.write(text);
+}
+
+function toCsv(rows) {
+  const list = Array.isArray(rows) ? rows : [rows];
+  if (list.length === 0) return "";
+  const columns = [...new Set(list.flatMap((row) => Object.keys(row)))];
+  return `${columns.map(csvCell).join(",")}\n${list.map((row) => columns.map((column) => csvCell(row[column])).join(",")).join("\n")}\n`;
+}
+
 function assertKeyProvider(provider) {
   if (provider !== "openai" && provider !== "openrouter") {
     throw new Error("Провайдер должен быть openai или openrouter.");
@@ -1951,6 +2626,9 @@ async function aiAsk(args, context = {}) {
 
   const config = await loadConfig();
   const providerConfig = resolveAiProfile(config, options);
+  if (options.tools && providerConfig.provider === "ollama") {
+    return localToolAsk(question, providerConfig, options);
+  }
   applyRuntimeConfig(providerConfig, options.config);
   const dataContext = await buildDataContext(question);
   emitEvent(options, "context_loaded", { schools: dataContext.schools.length, kindergartens: dataContext.kindergartens.length });
@@ -2014,6 +2692,132 @@ function resolveAiProfile(config, options = {}) {
   };
 }
 
+async function localToolAsk(question, providerConfig, options) {
+  await ensureLocalData();
+  const plan = await buildLocalToolPlan(question, providerConfig, options);
+  const validated = validateToolPlan(plan);
+  const result = await executeToolPlan(validated);
+  const answer = formatToolResult(result, options);
+
+  if (!options["no-history"] && isFeatureEnabled("sqlite-history")) {
+    recordAskHistory({
+      question,
+      answer,
+      providerConfig,
+      dataContext: { tool_plan: validated, tool_result: result },
+      error: "",
+      sessionId: null,
+    });
+  }
+
+  emitEvent(options, "tool_plan", { plan: validated });
+  if (options.output) await writeFile(options.output, answer, "utf8");
+  if (options.format === "json" || options.schema === "json") {
+    printJson({ answer, plan: validated, result });
+  } else {
+    console.log(answer);
+  }
+  return answer;
+}
+
+async function buildLocalToolPlan(question, providerConfig, options) {
+  const mode = options.reasoning || "verify";
+  const prompt = [
+    "Ты планировщик CLI iola. Верни только JSON.",
+    "Доступные tools: search_local, get_card, export_data, run_report, save_view.",
+    "Схема: {\"steps\":[{\"tool\":\"search_local\",\"args\":{\"dataset\":\"schools|kindergartens|all\",\"query\":\"text\",\"limit\":10}}]}",
+    "Для выгрузки CSV добавь export_data с format=csv и output, если пользователь назвал файл.",
+    `Вопрос: ${question}`,
+  ].join("\n");
+
+  try {
+    const raw = await callOllama(providerConfig, [{ role: "user", content: prompt }]);
+    const parsed = parseJsonObject(raw);
+    if (mode === "vote") {
+      return chooseBestPlan([parsed, inferToolPlan(question)]);
+    }
+    return parsed;
+  } catch {
+    return inferToolPlan(question);
+  }
+}
+
+function parseJsonObject(text) {
+  const match = String(text).match(/\{[\s\S]*\}/);
+  if (!match) throw new Error("JSON-план не найден.");
+  return JSON.parse(match[0]);
+}
+
+function inferToolPlan(question) {
+  const normalized = question.toLocaleLowerCase("ru-RU");
+  const dataset = normalized.includes("сад") ? "kindergartens" : normalized.includes("школ") || normalized.includes("лицей") ? "schools" : "all";
+  const steps = [];
+  if (normalized.includes("без телефона")) {
+    steps.push({ tool: "run_report", args: { name: "missing-phones" } });
+  } else {
+    const query = normalized.match(/петрова|школ[а-яё ]*\d+|сад[а-яё ]*\d+|лицей[а-яё ]*\d+/iu)?.[0] || question;
+    steps.push({ tool: "search_local", args: { dataset, query, limit: 20 } });
+  }
+  if (normalized.includes("csv") || normalized.includes("выгруз")) {
+    steps.push({ tool: "export_data", args: { format: "csv", output: normalized.match(/([a-z0-9_-]+\.csv)/i)?.[1] || "iola-export.csv" } });
+  }
+  return { steps };
+}
+
+function chooseBestPlan(plans) {
+  return plans.find((plan) => {
+    try {
+      validateToolPlan(plan);
+      return true;
+    } catch {
+      return false;
+    }
+  }) || plans.at(-1);
+}
+
+function validateToolPlan(plan) {
+  const allowed = new Set(["search_local", "get_card", "export_data", "run_report", "save_view"]);
+  if (!plan || !Array.isArray(plan.steps)) throw new Error("Некорректный tool-plan.");
+  for (const step of plan.steps) {
+    if (!allowed.has(step.tool)) throw new Error(`Недопустимый tool: ${step.tool}`);
+  }
+  return plan;
+}
+
+async function executeToolPlan(plan) {
+  let current = [];
+  const outputs = [];
+  for (const step of plan.steps) {
+    if (step.tool === "search_local") {
+      current = searchLocalRecords(step.args?.query || "", { dataset: step.args?.dataset || "all", limit: step.args?.limit || 20, fts: true });
+      outputs.push({ tool: step.tool, rows: current.length });
+    } else if (step.tool === "get_card") {
+      const card = findCard(step.args?.query || "");
+      current = card ? [card] : [];
+      outputs.push({ tool: step.tool, rows: current.length });
+    } else if (step.tool === "run_report") {
+      current = runQuality(step.args?.name || "all");
+      outputs.push({ tool: step.tool, rows: current.length });
+    } else if (step.tool === "save_view") {
+      saveView(step.args?.name, step.args?.dataset || "all", step.args?.args || []);
+      outputs.push({ tool: step.tool, saved: step.args?.name });
+    } else if (step.tool === "export_data") {
+      const text = step.args?.format === "json" ? JSON.stringify(current, null, 2) : toCsv(current);
+      await writeFile(step.args?.output || "iola-export.csv", text, "utf8");
+      outputs.push({ tool: step.tool, output: step.args?.output || "iola-export.csv", rows: current.length });
+    }
+  }
+  return { rows: current, outputs };
+}
+
+function formatToolResult(result, options) {
+  if (options.schema === "json") return JSON.stringify(result, null, 2);
+  const exported = result.outputs.find((item) => item.output);
+  if (exported) return `Готово. Файл сохранен: ${exported.output}. Записей: ${exported.rows}`;
+  if (!result.rows.length) return "Данных не найдено.";
+  return result.rows.slice(0, 10).map((row) => `${row.name || row.check}: ${row.address || row.count || ""}`).join("\n");
+}
+
 function applyRuntimeConfig(target, value) {
   if (!value) {
     return;
@@ -2396,20 +3200,26 @@ async function listDataset(dataset, args) {
   params.set("limit", options.limit || "20");
   params.set("offset", options.offset || "0");
 
-  const data = await fetchJson(`${await getApiBaseUrl()}/${DATASETS[dataset].endpoint}?${params}`);
-  const items = normalizeItems(data);
+  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));
+  const items = data;
   const filtered = applyDatasetFilters(items, options);
   const limited = filtered.slice(0, Number(options.limit || 20));
   const summarized = limited.map(selectPublicSummary);
   const projected = projectColumns(summarized, options.columns);
+  if (options.save) {
+    saveView(options.save, dataset, args.filter((arg) => arg !== "--save" && arg !== options.save));
+    console.log(`View сохранен: ${options.save}`);
+  }
 
   if (options.json || options.format === "json") {
-    printJson(projected);
+    await outputData(projected, options, "json");
     return;
   }
 
   if (options.format === "csv") {
-    printCsv(projected);
+    await outputData(projected, options, "csv");
     return;
   }
 
@@ -2444,27 +3254,32 @@ async function searchAll(args) {
     throw new Error('Search text is required. Example: iola search "лицей"');
   }
 
-  const [schools, kindergartens] = await Promise.all([
-    fetchJson(`${await getApiBaseUrl()}/schools?limit=100&offset=0`),
-    fetchJson(`${await getApiBaseUrl()}/kindergartens?limit=100&offset=0`),
-  ]);
-
   const limit = Number(options.limit || 5);
+  const [schools, kindergartens] = options.local
+    ? [
+        searchLocalRecords(query, { dataset: "schools", limit, fts: options.fts }),
+        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),
+      ]);
+
   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),
   };
 
   if (options.json || options.format === "json") {
-    printJson(result);
+    await outputData(result, options, "json");
     return;
   }
 
   if (options.format === "csv") {
-    printCsv([
+    await outputData([
       ...result.schools.map((item) => ({ layer: "schools", ...item })),
       ...result.kindergartens.map((item) => ({ layer: "kindergartens", ...item })),
-    ]);
+    ], options, "csv");
     return;
   }
 
@@ -2492,12 +3307,12 @@ function parseOptions(args) {
 
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
-    if (arg === "--json" || arg === "--yes" || arg === "--silent" || arg === "--events" || arg === "--no-history" || arg === "--summary" || arg === "--all") {
+    if (arg === "--json" || arg === "--yes" || arg === "--silent" || arg === "--events" || arg === "--no-history" || arg === "--summary" || arg === "--all" || arg === "--local" || arg === "--cache" || arg === "--tools" || arg === "--fts") {
       result[arg.slice(2)] = true;
     } else if (arg === "--check" || arg === "--upgrade-node") {
       result.check = true;
       result[arg.slice(2)] = true;
-    } else if (arg === "--limit" || arg === "--offset" || arg === "--search" || arg === "--where" || arg === "--columns" || arg === "--inn" || arg === "--model" || arg === "--provider" || arg === "--profile" || arg === "--name" || arg === "--base-url" || arg === "--sandbox" || arg === "--approval" || arg === "--cwd" || arg === "--codex-profile" || arg === "--format" || arg === "--output" || arg === "--schema" || arg === "--session" || arg === "--temperature" || arg === "--config") {
+    } else if (arg === "--limit" || arg === "--offset" || arg === "--search" || arg === "--where" || arg === "--columns" || arg === "--inn" || arg === "--model" || arg === "--provider" || arg === "--profile" || arg === "--name" || arg === "--base-url" || arg === "--sandbox" || arg === "--approval" || arg === "--cwd" || arg === "--codex-profile" || arg === "--format" || arg === "--output" || arg === "--schema" || arg === "--session" || arg === "--temperature" || arg === "--config" || arg === "--dataset" || arg === "--save" || arg === "--reasoning") {
       result[arg.slice(2)] = args[index + 1];
       index += 1;
     } else {