@tikoci/rosetta 0.2.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tikoci/rosetta",
+  "version": "0.2.0",
+  "description": "RouterOS documentation as SQLite FTS5 — RAG search + command glossary via MCP",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "rosetta": "bin/rosetta.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tikoci/rosetta.git"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "matrix/"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit",
+    "lint": "biome check src/"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.7",
+    "@types/bun": "^1.3.10",
+    "linkedom": "^0.18.9",
+    "typescript": "^6.0.2"
+  }
+}

package/src/assess-html.ts

@@ -0,0 +1,267 @@
+#!/usr/bin/env bun
+
+/**
+ * assess-html.ts — Evaluate the Confluence HTML export for parseability.
+ *
+ * Analyzes all HTML files in the export directory and outputs:
+ * - Page count, text volume, code blocks, table counts
+ * - Property table detection (confluenceTable with Property|Description headers)
+ * - Breadcrumb depth distribution
+ * - Menu paths found in code blocks and body text
+ * - Edge cases and anomalies
+ *
+ * Usage: bun run src/assess-html.ts [html-dir]
+ */
+
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { parseHTML } from "linkedom";
+
+const HTML_DIR = process.argv[2] || resolve(import.meta.dirname, "../box/latest/ROS");
+
+const htmlFiles = readdirSync(HTML_DIR)
+  .filter((f) => f.endsWith(".html") && f !== "index.html")
+  .sort();
+
+console.log(`Scanning ${htmlFiles.length} HTML files in ${HTML_DIR}\n`);
+
+// Filename pattern: Slug_PageID.html or just PageID.html
+const filenameRe = /^(?:(.+?)_)?(\d+)\.html$/;
+// RouterOS menu path pattern
+const menuPathRe = /\/[a-z][a-z0-9-]*(?:\/[a-z][a-z0-9-]*)*/g;
+
+interface PageInfo {
+  file: string;
+  pageId: number;
+  slug: string;
+  title: string;
+  breadcrumbs: string[];
+  depth: number;
+  wordCount: number;
+  codeBlocks: number;
+  codeLines: number;
+  codeLangs: string[];
+  tables: number;
+  propertyTables: number;
+  propertyCount: number;
+  menuPaths: string[];
+  listProperties: number;
+}
+
+const pages: PageInfo[] = [];
+const depthDist: Record<number, number> = {};
+const allMenuPaths = new Set<string>();
+const tablHeaderPatterns: Record<string, number> = {};
+const codeLangDist: Record<string, number> = {};
+const anomalies: string[] = [];
+
+for (const file of htmlFiles) {
+  const html = readFileSync(resolve(HTML_DIR, file), "utf-8");
+  const { document } = parseHTML(html);
+
+  // Parse filename
+  const match = basename(file).match(filenameRe);
+  const pageId = match ? Number(match[2]) : 0;
+  const slug = match?.[1] || "";
+
+  if (!pageId) {
+    anomalies.push(`No page ID in filename: ${file}`);
+  }
+
+  // Title
+  const titleEl = document.querySelector("#title-text");
+  const title = titleEl?.textContent?.replace(/^\s*RouterOS\s*:\s*/i, "").trim() || "";
+
+  // Breadcrumbs
+  const breadcrumbs: string[] = [];
+  for (const li of document.querySelectorAll("#breadcrumbs li")) {
+    const a = li.querySelector("a");
+    if (a) breadcrumbs.push(a.textContent?.trim() || "");
+  }
+  const depth = breadcrumbs.length;
+  depthDist[depth] = (depthDist[depth] || 0) + 1;
+
+  // Text content
+  const mainContent = document.querySelector("#main-content");
+  const text = mainContent?.textContent || "";
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
+
+  // Code blocks
+  const codeEls = document.querySelectorAll("pre.syntaxhighlighter-pre");
+  const codeLangs: string[] = [];
+  let codeLines = 0;
+  for (const el of codeEls) {
+    const params = el.getAttribute("data-syntaxhighlighter-params") || "";
+    const brushMatch = params.match(/brush:\s*(\w+)/);
+    if (brushMatch) {
+      const lang = brushMatch[1];
+      codeLangs.push(lang);
+      codeLangDist[lang] = (codeLangDist[lang] || 0) + 1;
+    }
+    codeLines += (el.textContent || "").split("\n").filter((l) => l.trim()).length;
+  }
+
+  // Tables — classify headers
+  const tables = document.querySelectorAll("table.confluenceTable");
+  let propertyTables = 0;
+  let propertyCount = 0;
+  for (const table of tables) {
+    const headerCells = Array.from(table.querySelectorAll("th.confluenceTh, thead th"));
+    const headerText = headerCells.map((th) => th.textContent?.trim() || "").join(" | ");
+    if (headerText) {
+      tablHeaderPatterns[headerText] = (tablHeaderPatterns[headerText] || 0) + 1;
+    }
+
+    // Detect property tables: first header is "Property" (case-insensitive)
+    const isPropertyTable = headerCells.some(
+      (th) => th.textContent?.trim().toLowerCase() === "property"
+    );
+    if (isPropertyTable) {
+      propertyTables++;
+      // Count data rows (skip header)
+      const rows = table.querySelectorAll("tbody tr");
+      // First row might be header in tbody (no thead)
+      const firstRowIsHeader = headerCells.length > 0;
+      propertyCount += Math.max(0, rows.length - (firstRowIsHeader ? 1 : 0));
+    }
+  }
+
+  // List-based properties: <ul>/<li> with <strong> followed by parenthetical type
+  let listProperties = 0;
+  if (mainContent) {
+    for (const li of mainContent.querySelectorAll("ul > li")) {
+      const strong = li.querySelector("strong");
+      if (strong && li.textContent?.includes("(")) {
+        listProperties++;
+      }
+    }
+  }
+
+  // Menu paths from code blocks and body
+  const menuPaths: string[] = [];
+  const bodyText = mainContent?.textContent || "";
+  for (const m of bodyText.matchAll(menuPathRe)) {
+    const p = m[0];
+    // Filter noise: must be at least 2 segments and look like a RouterOS path
+    if (p.split("/").length >= 3 && !p.includes("http") && !p.includes("www")) {
+      menuPaths.push(p);
+      allMenuPaths.add(p);
+    }
+  }
+
+  pages.push({
+    file,
+    pageId,
+    slug,
+    title,
+    breadcrumbs,
+    depth,
+    wordCount,
+    codeBlocks: codeEls.length,
+    codeLines,
+    codeLangs: [...new Set(codeLangs)],
+    tables: tables.length,
+    propertyTables,
+    propertyCount,
+    menuPaths: [...new Set(menuPaths)],
+    listProperties,
+  });
+}
+
+// Summary stats
+const totalWords = pages.reduce((s, p) => s + p.wordCount, 0);
+const totalCodeLines = pages.reduce((s, p) => s + p.codeLines, 0);
+const totalCodeBlocks = pages.reduce((s, p) => s + p.codeBlocks, 0);
+const totalTables = pages.reduce((s, p) => s + p.tables, 0);
+const totalPropertyTables = pages.reduce((s, p) => s + p.propertyTables, 0);
+const totalProperties = pages.reduce((s, p) => s + p.propertyCount, 0);
+const totalListProps = pages.reduce((s, p) => s + p.listProperties, 0);
+const pagesWithPropertyTables = pages.filter((p) => p.propertyTables > 0).length;
+const pagesWithMenuPaths = pages.filter((p) => p.menuPaths.length > 0).length;
+const pagesWithCode = pages.filter((p) => p.codeBlocks > 0).length;
+
+console.log("=== HTML Archive Assessment ===\n");
+console.log(`Pages:              ${pages.length}`);
+console.log(`Total words:        ${totalWords.toLocaleString()}`);
+console.log(`Total code blocks:  ${totalCodeBlocks}`);
+console.log(`Total code lines:   ${totalCodeLines.toLocaleString()}`);
+console.log(`Pages with code:    ${pagesWithCode}`);
+console.log(`Total tables:       ${totalTables}`);
+console.log(`Property tables:    ${totalPropertyTables} (in ${pagesWithPropertyTables} pages)`);
+console.log(`Properties (table): ${totalProperties}`);
+console.log(`Properties (list):  ${totalListProps}`);
+console.log(`Unique menu paths:  ${allMenuPaths.size}`);
+console.log(`Pages w/ menu path: ${pagesWithMenuPaths}`);
+
+console.log("\n--- Breadcrumb Depth Distribution ---");
+for (const [depth, count] of Object.entries(depthDist).sort(([a], [b]) => +a - +b)) {
+  console.log(`  depth ${depth}: ${count} pages`);
+}
+
+console.log("\n--- Code Language Distribution ---");
+for (const [lang, count] of Object.entries(codeLangDist).sort(([, a], [, b]) => b - a)) {
+  console.log(`  ${lang}: ${count} blocks`);
+}
+
+console.log("\n--- Table Header Patterns (top 20) ---");
+const sortedHeaders = Object.entries(tablHeaderPatterns).sort(([, a], [, b]) => b - a);
+for (const [header, count] of sortedHeaders.slice(0, 20)) {
+  console.log(`  [${count}x] ${header}`);
+}
+
+console.log("\n--- Largest Pages (by word count) ---");
+const byWords = [...pages].sort((a, b) => b.wordCount - a.wordCount);
+for (const p of byWords.slice(0, 15)) {
+  console.log(`  ${p.wordCount.toLocaleString()} words — ${p.title || p.file} (${p.propertyTables} prop tables, ${p.codeBlocks} code blocks)`);
+}
+
+console.log("\n--- Pages Without Property Tables (sample) ---");
+const noProps = pages.filter((p) => p.propertyTables === 0 && p.wordCount > 100);
+for (const p of noProps.slice(0, 10)) {
+  console.log(`  ${p.title || p.file} — ${p.wordCount} words, ${p.tables} tables, ${p.listProperties} list props`);
+}
+
+if (anomalies.length > 0) {
+  console.log("\n--- Anomalies ---");
+  for (const a of anomalies) console.log(`  ${a}`);
+}
+
+// Top menu paths
+console.log("\n--- Unique Menu Paths (sample, top 30) ---");
+const sortedPaths = [...allMenuPaths].sort();
+for (const p of sortedPaths.slice(0, 30)) {
+  console.log(`  ${p}`);
+}
+
+// Write summary JSON
+const summary = {
+  pageCount: pages.length,
+  totalWords,
+  totalCodeBlocks,
+  totalCodeLines,
+  totalTables,
+  totalPropertyTables,
+  totalProperties,
+  totalListProps,
+  uniqueMenuPaths: allMenuPaths.size,
+  depthDistribution: depthDist,
+  codeLangDistribution: codeLangDist,
+  tableHeaderPatterns: Object.fromEntries(sortedHeaders),
+  pages: pages.map((p) => ({
+    file: p.file,
+    pageId: p.pageId,
+    title: p.title,
+    depth: p.depth,
+    wordCount: p.wordCount,
+    codeBlocks: p.codeBlocks,
+    tables: p.tables,
+    propertyTables: p.propertyTables,
+    propertyCount: p.propertyCount,
+    listProperties: p.listProperties,
+    menuPaths: p.menuPaths,
+  })),
+};
+
+const outPath = resolve(import.meta.dirname, "../ros-html-assessment.json");
+await Bun.write(outPath, JSON.stringify(summary, null, 2));
+console.log(`\nFull assessment written to ${outPath}`);

package/src/db.ts

@@ -0,0 +1,360 @@
+/**
+ * db.ts — SQLite schema for RouterOS documentation.
+ *
+ * DB path: DB_PATH env var, or <project-root>/ros-help.db
+ *
+ * Tables:
+ *   pages            — one row per Confluence HTML page
+ *   pages_fts        — FTS5 over title, path, text, code
+ *   properties       — extracted property tables (name, type, default, description)
+ *   properties_fts   — FTS5 over name, description
+ *   callouts         — note/warning/info callout blocks from pages
+ *   callouts_fts     — FTS5 over callout content
+ *   commands         — RouterOS command tree from inspect.json (latest version)
+ *   command_versions — junction: which commands exist in which RouterOS versions
+ *   ros_versions     — metadata for each extracted RouterOS version
+ *   devices          — MikroTik product hardware specs from product matrix CSV
+ *   devices_fts      — FTS5 over product name, code, architecture, CPU
+ *   changelogs       — parsed changelog entries per RouterOS version
+ *   changelogs_fts   — FTS5 over category, description
+ */
+
+import sqlite from "bun:sqlite";
+import path from "node:path";
+
+declare const IS_COMPILED: boolean;
+
+/**
+ * Resolve the base directory for finding ros-help.db:
+ * - Compiled binary: directory containing the executable
+ * - Dev mode: project root (one level up from src/)
+ */
+const baseDir =
+  typeof IS_COMPILED !== "undefined" && IS_COMPILED
+    ? path.dirname(process.execPath)
+    : path.resolve(import.meta.dirname, "..");
+
+export const DB_PATH =
+  process.env.DB_PATH?.trim() || path.join(baseDir, "ros-help.db");
+
+export const db = new sqlite(DB_PATH);
+
+export function initDb() {
+  db.run("PRAGMA journal_mode=WAL;");
+  db.run("PRAGMA foreign_keys=ON;");
+
+  db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
+    version TEXT PRIMARY KEY,
+    applied_at TEXT NOT NULL
+  );`);
+
+  // -- Pages (from Confluence HTML export) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS pages (
+    id           INTEGER PRIMARY KEY,
+    slug         TEXT NOT NULL,
+    title        TEXT NOT NULL,
+    path         TEXT NOT NULL,
+    depth        INTEGER NOT NULL,
+    parent_id    INTEGER REFERENCES pages(id),
+    url          TEXT NOT NULL,
+    text         TEXT NOT NULL,
+    code         TEXT NOT NULL,
+    code_lang    TEXT,
+    author       TEXT,
+    last_updated TEXT,
+    word_count   INTEGER NOT NULL,
+    code_lines   INTEGER NOT NULL,
+    html_file    TEXT NOT NULL
+  );`);
+
+  db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS pages_fts USING fts5(
+    title, path, text, code,
+    content=pages,
+    content_rowid=id,
+    tokenize='porter unicode61'
+  );`);
+
+  db.run(`CREATE TRIGGER IF NOT EXISTS pages_ai AFTER INSERT ON pages BEGIN
+    INSERT INTO pages_fts(rowid, title, path, text, code)
+    VALUES (new.id, new.title, new.path, new.text, new.code);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS pages_ad AFTER DELETE ON pages BEGIN
+    INSERT INTO pages_fts(pages_fts, rowid, title, path, text, code)
+    VALUES('delete', old.id, old.title, old.path, old.text, old.code);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS pages_au AFTER UPDATE ON pages BEGIN
+    INSERT INTO pages_fts(pages_fts, rowid, title, path, text, code)
+    VALUES('delete', old.id, old.title, old.path, old.text, old.code);
+    INSERT INTO pages_fts(rowid, title, path, text, code)
+    VALUES (new.id, new.title, new.path, new.text, new.code);
+  END;`);
+
+  // -- Properties (extracted from confluenceTable) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS properties (
+    id          INTEGER PRIMARY KEY,
+    page_id     INTEGER NOT NULL REFERENCES pages(id),
+    name        TEXT NOT NULL,
+    type        TEXT,
+    default_val TEXT,
+    description TEXT NOT NULL,
+    section     TEXT,
+    sort_order  INTEGER NOT NULL,
+    UNIQUE(page_id, name, section)
+  );`);
+
+  db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS properties_fts USING fts5(
+    name, description,
+    content=properties,
+    content_rowid=id,
+    tokenize='porter unicode61'
+  );`);
+
+  db.run(`CREATE TRIGGER IF NOT EXISTS props_ai AFTER INSERT ON properties BEGIN
+    INSERT INTO properties_fts(rowid, name, description)
+    VALUES (new.id, new.name, new.description);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS props_ad AFTER DELETE ON properties BEGIN
+    INSERT INTO properties_fts(properties_fts, rowid, name, description)
+    VALUES('delete', old.id, old.name, old.description);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS props_au AFTER UPDATE ON properties BEGIN
+    INSERT INTO properties_fts(properties_fts, rowid, name, description)
+    VALUES('delete', old.id, old.name, old.description);
+    INSERT INTO properties_fts(rowid, name, description)
+    VALUES (new.id, new.name, new.description);
+  END;`);
+
+  // -- Callouts (note/warning/info blocks from Confluence pages) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS callouts (
+    id          INTEGER PRIMARY KEY,
+    page_id     INTEGER NOT NULL REFERENCES pages(id),
+    type        TEXT NOT NULL,
+    content     TEXT NOT NULL,
+    sort_order  INTEGER NOT NULL
+  );`);
+
+  db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS callouts_fts USING fts5(
+    content,
+    content=callouts,
+    content_rowid=id,
+    tokenize='porter unicode61'
+  );`);
+
+  db.run(`CREATE TRIGGER IF NOT EXISTS callouts_ai AFTER INSERT ON callouts BEGIN
+    INSERT INTO callouts_fts(rowid, content)
+    VALUES (new.id, new.content);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS callouts_ad AFTER DELETE ON callouts BEGIN
+    INSERT INTO callouts_fts(callouts_fts, rowid, content)
+    VALUES('delete', old.id, old.content);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS callouts_au AFTER UPDATE ON callouts BEGIN
+    INSERT INTO callouts_fts(callouts_fts, rowid, content)
+    VALUES('delete', old.id, old.content);
+    INSERT INTO callouts_fts(rowid, content)
+    VALUES (new.id, new.content);
+  END;`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_callouts_page ON callouts(page_id);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_callouts_type ON callouts(type);`);
+
+  // -- Sections (page chunks split by headings, for large-page retrieval) --
+
+  // Migration: drop legacy sections table (from PDF-era schema) if it lacks page_id
+  const secCols = db.prepare("SELECT name FROM pragma_table_info('sections')").all() as Array<{ name: string }>;
+  if (secCols.length > 0 && !secCols.some((c) => c.name === "page_id")) {
+    db.run("DROP TABLE sections;");
+  }
+
+  db.run(`CREATE TABLE IF NOT EXISTS sections (
+    id          INTEGER PRIMARY KEY,
+    page_id     INTEGER NOT NULL REFERENCES pages(id),
+    heading     TEXT NOT NULL,
+    level       INTEGER NOT NULL,
+    anchor_id   TEXT NOT NULL,
+    text        TEXT NOT NULL,
+    code        TEXT NOT NULL,
+    word_count  INTEGER NOT NULL,
+    sort_order  INTEGER NOT NULL
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sections_page ON sections(page_id);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sections_anchor ON sections(page_id, anchor_id);`);
+
+  // -- Commands (from inspect.json) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS commands (
+    id          INTEGER PRIMARY KEY,
+    path        TEXT NOT NULL UNIQUE,
+    name        TEXT NOT NULL,
+    type        TEXT NOT NULL,
+    parent_path TEXT,
+    page_id     INTEGER REFERENCES pages(id),
+    description TEXT,
+    ros_version TEXT
+  );`);
+
+  // Migration: add ros_version column if missing (from pre-version schema)
+  const cmdCols = db.prepare("PRAGMA table_info(commands)").all() as Array<{ name: string }>;
+  if (!cmdCols.some((c) => c.name === "ros_version")) {
+    db.run("ALTER TABLE commands ADD COLUMN ros_version TEXT;");
+  }
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_commands_parent ON commands(parent_path);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_commands_page ON commands(page_id);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_commands_type ON commands(type);`);
+
+  // -- Command version tracking --
+
+  db.run(`CREATE TABLE IF NOT EXISTS ros_versions (
+    version        TEXT PRIMARY KEY,
+    channel        TEXT,
+    extra_packages INTEGER NOT NULL DEFAULT 0,
+    extracted_at   TEXT NOT NULL
+  );`);
+
+  db.run(`CREATE TABLE IF NOT EXISTS command_versions (
+    command_path TEXT NOT NULL,
+    ros_version  TEXT NOT NULL REFERENCES ros_versions(version),
+    PRIMARY KEY (command_path, ros_version)
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_cmdver_version ON command_versions(ros_version);`);
+
+  // -- Devices (MikroTik product matrix) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS devices (
+    id                INTEGER PRIMARY KEY AUTOINCREMENT,
+    product_name      TEXT NOT NULL UNIQUE,
+    product_code      TEXT,
+    architecture      TEXT,
+    cpu               TEXT,
+    cpu_cores         INTEGER,
+    cpu_frequency     TEXT,
+    license_level     INTEGER,
+    operating_system  TEXT,
+    ram               TEXT,
+    ram_mb            INTEGER,
+    storage           TEXT,
+    storage_mb        INTEGER,
+    dimensions        TEXT,
+    poe_in            TEXT,
+    poe_out           TEXT,
+    poe_out_ports     TEXT,
+    poe_in_voltage    TEXT,
+    dc_inputs         INTEGER,
+    dc_jack_voltage   TEXT,
+    max_power_w       REAL,
+    wireless_24_chains INTEGER,
+    antenna_24_dbi    REAL,
+    wireless_5_chains INTEGER,
+    antenna_5_dbi     REAL,
+    eth_fast          INTEGER,
+    eth_gigabit       INTEGER,
+    eth_2500          INTEGER,
+    usb_ports         INTEGER,
+    combo_ports       INTEGER,
+    sfp_ports         INTEGER,
+    sfp_plus_ports    INTEGER,
+    eth_multigig      INTEGER,
+    sim_slots         INTEGER,
+    memory_cards      TEXT,
+    usb_type          TEXT,
+    msrp_usd          REAL
+  );`);
+
+  db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS devices_fts USING fts5(
+    product_name, product_code, architecture, cpu,
+    content=devices,
+    content_rowid=id,
+    tokenize='unicode61'
+  );`);
+
+  db.run(`CREATE TRIGGER IF NOT EXISTS devices_ai AFTER INSERT ON devices BEGIN
+    INSERT INTO devices_fts(rowid, product_name, product_code, architecture, cpu)
+    VALUES (new.id, new.product_name, new.product_code, new.architecture, new.cpu);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS devices_ad AFTER DELETE ON devices BEGIN
+    INSERT INTO devices_fts(devices_fts, rowid, product_name, product_code, architecture, cpu)
+    VALUES('delete', old.id, old.product_name, old.product_code, old.architecture, old.cpu);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS devices_au AFTER UPDATE ON devices BEGIN
+    INSERT INTO devices_fts(devices_fts, rowid, product_name, product_code, architecture, cpu)
+    VALUES('delete', old.id, old.product_name, old.product_code, old.architecture, old.cpu);
+    INSERT INTO devices_fts(rowid, product_name, product_code, architecture, cpu)
+    VALUES (new.id, new.product_name, new.product_code, new.architecture, new.cpu);
+  END;`);
+
+  // -- Changelogs (parsed per-entry from MikroTik download server) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS changelogs (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    version     TEXT NOT NULL,
+    released    TEXT,
+    category    TEXT NOT NULL,
+    is_breaking INTEGER NOT NULL DEFAULT 0,
+    description TEXT NOT NULL,
+    sort_order  INTEGER NOT NULL,
+    UNIQUE(version, sort_order)
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_changelogs_version ON changelogs(version);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_changelogs_category ON changelogs(category);`);
+
+  db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS changelogs_fts USING fts5(
+    category, description,
+    content=changelogs,
+    content_rowid=id,
+    tokenize='porter unicode61'
+  );`);
+
+  db.run(`CREATE TRIGGER IF NOT EXISTS changelogs_ai AFTER INSERT ON changelogs BEGIN
+    INSERT INTO changelogs_fts(rowid, category, description)
+    VALUES (new.id, new.category, new.description);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS changelogs_ad AFTER DELETE ON changelogs BEGIN
+    INSERT INTO changelogs_fts(changelogs_fts, rowid, category, description)
+    VALUES('delete', old.id, old.category, old.description);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS changelogs_au AFTER UPDATE ON changelogs BEGIN
+    INSERT INTO changelogs_fts(changelogs_fts, rowid, category, description)
+    VALUES('delete', old.id, old.category, old.description);
+    INSERT INTO changelogs_fts(rowid, category, description)
+    VALUES (new.id, new.category, new.description);
+  END;`);
+}
+
+export function getDbStats() {
+  const count = (sql: string) =>
+    Number((db.prepare(sql).get() as { c: number }).c ?? 0);
+  const scalar = (sql: string) => {
+    const row = db.prepare(sql).get() as { v: string | null } | null;
+    return row?.v ?? null;
+  };
+  return {
+    db_path: DB_PATH,
+    pages: count("SELECT COUNT(*) AS c FROM pages"),
+    sections: count("SELECT COUNT(*) AS c FROM sections"),
+    properties: count("SELECT COUNT(*) AS c FROM properties"),
+    callouts: count("SELECT COUNT(*) AS c FROM callouts"),
+    commands: count("SELECT COUNT(*) AS c FROM commands"),
+    commands_linked: count("SELECT COUNT(*) AS c FROM commands WHERE page_id IS NOT NULL"),
+    devices: count("SELECT COUNT(*) AS c FROM devices"),
+    changelogs: count("SELECT COUNT(*) AS c FROM changelogs"),
+    changelog_versions: count("SELECT COUNT(DISTINCT version) AS c FROM changelogs"),
+    ros_versions: count("SELECT COUNT(*) AS c FROM ros_versions"),
+    ros_version_min: scalar("SELECT MIN(version) AS v FROM ros_versions"),
+    ros_version_max: scalar("SELECT MAX(version) AS v FROM ros_versions"),
+    doc_export: "2026-03-25 (Confluence HTML)",
+  };
+}
+
+// Run schema init when executed directly
+if (import.meta.main) {
+  initDb();
+  console.log("Schema initialized:", DB_PATH);
+  console.log(getDbStats());
+}