@tikoci/rosetta 0.4.0 → 0.4.2

package/src/query.ts

@@ -25,6 +25,8 @@ export type SearchResponse = {
   total: number;
 };
 
+type CsvScalar = string | number | null;
+
 const DEFAULT_LIMIT = 8;
 const MAX_TERMS = 8;
 const MIN_TERM_LENGTH = 2;
@@ -85,6 +87,21 @@ const COMPOUND_TERMS: [string, string][] = [
   ["address", "list"],
 ];
 
+function escapeCsv(value: CsvScalar): string {
+  if (value === null) return "";
+  const text = String(value);
+  return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+
+function rowsToCsv<T extends Record<string, CsvScalar>>(
+  rows: T[],
+  columns: Array<keyof T & string>,
+): string {
+  const header = columns.join(",");
+  const body = rows.map((row) => columns.map((column) => escapeCsv(row[column] ?? null)).join(",")).join("\n");
+  return body ? `${header}\n${body}\n` : `${header}\n`;
+}
+
 export function extractTerms(question: string): string[] {
   return question
     .toLowerCase()
@@ -577,6 +594,79 @@ function runCalloutsFtsQuery(
   }
 }
 
+/** Diff two RouterOS versions — which command paths were added/removed between them. */
+export type CommandDiffResult = {
+  from_version: string;
+  to_version: string;
+  path_prefix: string | null;
+  added: string[];
+  removed: string[];
+  added_count: number;
+  removed_count: number;
+  note: string | null;
+};
+
+export function diffCommandVersions(
+  fromVersion: string,
+  toVersion: string,
+  pathPrefix?: string,
+): CommandDiffResult {
+  const allVersionRows = db
+    .prepare("SELECT version FROM ros_versions")
+    .all() as Array<{ version: string }>;
+  const knownVersions = allVersionRows.map((r) => r.version).sort(compareVersions);
+
+  const notes: string[] = [];
+  if (knownVersions.length > 0 && !knownVersions.includes(fromVersion)) {
+    notes.push(`Version ${fromVersion} is not in the tracked range (${knownVersions[0]}–${knownVersions[knownVersions.length - 1]}). Results may be incomplete.`);
+  }
+  if (knownVersions.length > 0 && !knownVersions.includes(toVersion)) {
+    notes.push(`Version ${toVersion} is not in the tracked range (${knownVersions[0]}–${knownVersions[knownVersions.length - 1]}). Results may be incomplete.`);
+  }
+
+  const prefix = pathPrefix || null;  // treat empty string same as undefined
+  // Match the prefix itself OR any sub-path under it
+  const prefixFilter = prefix ? " AND (command_path = ? OR command_path LIKE ? || '/%')" : "";
+  const prefixParams = (v: string) => prefix ? [v, prefix, prefix] : [v];
+
+  type Row = { command_path: string };
+
+  const addedRows = db
+    .prepare(
+      `SELECT DISTINCT cv_to.command_path
+       FROM command_versions cv_to
+       WHERE cv_to.ros_version = ?${prefixFilter}
+         AND cv_to.command_path NOT IN (
+           SELECT command_path FROM command_versions WHERE ros_version = ?${prefixFilter}
+         )
+       ORDER BY cv_to.command_path`,
+    )
+    .all(...prefixParams(toVersion), ...prefixParams(fromVersion)) as Row[];
+
+  const removedRows = db
+    .prepare(
+      `SELECT DISTINCT cv_from.command_path
+       FROM command_versions cv_from
+       WHERE cv_from.ros_version = ?${prefixFilter}
+         AND cv_from.command_path NOT IN (
+           SELECT command_path FROM command_versions WHERE ros_version = ?${prefixFilter}
+         )
+       ORDER BY cv_from.command_path`,
+    )
+    .all(...prefixParams(fromVersion), ...prefixParams(toVersion)) as Row[];
+
+  return {
+    from_version: fromVersion,
+    to_version: toVersion,
+    path_prefix: prefix,
+    added: addedRows.map((r) => r.command_path),
+    removed: removedRows.map((r) => r.command_path),
+    added_count: addedRows.length,
+    removed_count: removedRows.length,
+    note: notes.length > 0 ? notes.join(" ") : null,
+  };
+}
+
 /** Check which RouterOS versions include a given command path. */
 export function checkCommandVersions(
   commandPath: string,
@@ -678,6 +768,31 @@ export type DeviceTestResult = {
   throughput_mbps: number | null;
 };
 
+/** Map Unicode superscript digits to ASCII equivalents for product name matching.
+ *  MikroTik uses ² and ³ in product names (hAP ax³, hAP ac²), but users type ASCII. */
+const SUPERSCRIPT_TO_ASCII: [string, string][] = [
+  ['\u00B9', '1'], // ¹
+  ['\u00B2', '2'], // ²
+  ['\u00B3', '3'], // ³
+];
+
+/** SQL expression to normalize Unicode superscript digits in a column to ASCII.
+ *  Wraps the column in nested REPLACE calls. */
+const NORMALIZE_PRODUCT_NAME = (col: string) =>
+  SUPERSCRIPT_TO_ASCII.reduce(
+    (expr, [sup, ascii]) => `REPLACE(${expr}, '${sup}', '${ascii}')`,
+    col,
+  );
+
+/** Normalize a device query: replace Unicode superscript digits with ASCII. */
+export function normalizeDeviceQuery(query: string): string {
+  let result = query;
+  for (const [sup, ascii] of SUPERSCRIPT_TO_ASCII) {
+    result = result.replaceAll(sup, ascii);
+  }
+  return result;
+}
+
 export type DeviceResult = {
   id: number;
   product_name: string;
@@ -759,42 +874,114 @@ function buildDeviceFtsQuery(terms: string[], mode: "AND" | "OR"): string {
   return parts.join(mode === "AND" ? " AND " : " OR ");
 }
 
+/** Generate a disambiguation note when multiple devices matched a partial query.
+ *  Helps the MCP client present meaningful choices to the user. */
+function disambiguationNote(query: string, results: DeviceResult[]): string {
+  const names = results.map((r) => r.product_name);
+  // Find common prefix
+  const shortest = names.reduce((a, b) => (a.length < b.length ? a : b));
+  let prefix = "";
+  for (let i = 0; i < shortest.length; i++) {
+    if (names.every((n) => n[i]?.toLowerCase() === shortest[i]?.toLowerCase())) {
+      prefix += shortest[i];
+    } else break;
+  }
+  prefix = prefix.trim();
+  // Summarize key differences
+  const diffs: string[] = [];
+  const enclosures = new Set(names.map((n) => {
+    if (/\bOUT\b/i.test(n)) return "outdoor";
+    if (/\bIN\b/i.test(n)) return "indoor";
+    return null;
+  }).filter(Boolean));
+  if (enclosures.size > 1) diffs.push("enclosure (indoor/outdoor)");
+  const hasPoe = results.map((r) => !!(r.poe_in || r.poe_out));
+  if (hasPoe.includes(true) && hasPoe.includes(false)) diffs.push("PoE support");
+  const hasPoeOut = results.map((r) => !!r.poe_out);
+  if (!diffs.includes("PoE support") && hasPoeOut.includes(true) && hasPoeOut.includes(false)) diffs.push("PoE output");
+  const hasWireless = results.map((r) => !!(r.wireless_24_chains || r.wireless_5_chains));
+  if (hasWireless.includes(true) && hasWireless.includes(false)) diffs.push("wireless");
+  const lteCapable = results.map((r) => (r.sim_slots ?? 0) > 0);
+  if (lteCapable.includes(true) && lteCapable.includes(false)) diffs.push("LTE/cellular");
+  const family = prefix || query;
+  const diffStr = diffs.length > 0 ? ` Key differences: ${diffs.join(", ")}.` : "";
+  return `${results.length} devices match "${family}".${diffStr} Use the full product name for a specific device.`;
+}
+
 /** Look up a device by exact name or product code, then fall back to LIKE/FTS + filters. */
 export function searchDevices(
   query: string,
   filters: DeviceFilters = {},
   limit = 10,
-): { results: DeviceResult[]; mode: "exact" | "fts" | "like" | "filter" | "fts+or"; total: number } {
-  // 1. Try exact match on product_name or product_code
-  if (query) {
+): { results: DeviceResult[]; mode: "exact" | "fts" | "like" | "filter" | "fts+or"; total: number; has_more: boolean; note?: string } {
+  // Normalize Unicode superscripts → ASCII digits for all matching stages.
+  // Users type "ax3" for "ax³", "ac2" for "ac²" — normalize once, use everywhere.
+  const q = normalizeDeviceQuery(query);
+  const normalizedName = NORMALIZE_PRODUCT_NAME('product_name');
+
+  // 1. Try exact match on product_name or product_code.
+  //    Compares normalized query against both raw and superscript-normalized product_name.
+  if (q) {
     const exact = db
-      .prepare(`${DEVICE_SELECT} WHERE product_name = ? COLLATE NOCASE OR product_code = ? COLLATE NOCASE`)
-      .all(query, query) as DeviceResult[];
+      .prepare(`${DEVICE_SELECT} WHERE product_name = ? COLLATE NOCASE OR product_code = ? COLLATE NOCASE OR ${normalizedName} = ? COLLATE NOCASE`)
+      .all(q, q, q) as DeviceResult[];
     if (exact.length > 0) {
-      return { results: attachTestResults(exact), mode: "exact", total: exact.length };
+      return { results: attachTestResults(exact), mode: "exact", total: exact.length, has_more: false };
     }
   }
 
   // 2. LIKE-based prefix/substring match on product_name and product_code.
+  //    Splits on whitespace, dashes, and underscores so that dash-separated
+  //    queries like "rb5009-out" still find "RB5009UPr+S+OUT".
   //    For 144 rows this is instant and catches model number substrings
   //    that FTS5 token matching misses (e.g. "RB1100" → "RB1100AHx4").
-  if (query) {
-    const likeTerms = query
-      .trim()
-      .split(/\s+/)
-      .filter((t) => t.length >= 2)
+  //    Also normalizes product_name in SQL so "ax3" matches "ax³".
+  if (q) {
+    const rawTerms = q.trim().split(/[\s\-_]+/);
+    const longTerms = rawTerms.filter((t) => t.length >= 2);
+    // Preserve single-digit terms (version numbers like "3" in "hap ax 3")
+    // but only when accompanied by longer terms to avoid overly broad matches.
+    const digitTerms = rawTerms.filter((t) => t.length === 1 && /^\d$/.test(t));
+    const likeTerms = (longTerms.length > 0 ? [...longTerms, ...digitTerms] : longTerms)
       .map((t) => `%${t}%`);
     if (likeTerms.length > 0) {
       const likeConditions = likeTerms.map(
-        () => "(d.product_name LIKE ? COLLATE NOCASE OR d.product_code LIKE ? COLLATE NOCASE)",
+        () => `(${normalizedName} LIKE ? COLLATE NOCASE OR d.product_code LIKE ? COLLATE NOCASE)`,
       );
       const likeParams = likeTerms.flatMap((t) => [t, t]);
+      // Fetch limit+1 to detect truncation
       const likeSql = `${DEVICE_SELECT} d WHERE ${likeConditions.join(" AND ")} ORDER BY d.product_name LIMIT ?`;
-      const likeResults = db.prepare(likeSql).all(...likeParams, limit) as DeviceResult[];
+      const likeResults = db.prepare(likeSql).all(...likeParams, limit + 1) as DeviceResult[];
       if (likeResults.length > 0) {
+        const hasMore = likeResults.length > limit;
+        const trimmed = hasMore ? likeResults.slice(0, limit) : likeResults;
         // Attach test results for small result sets (likely specific device lookups)
-        if (likeResults.length <= 5) attachTestResults(likeResults);
-        return { results: likeResults, mode: "like", total: likeResults.length };
+        if (trimmed.length <= 5) attachTestResults(trimmed);
+        // Single match in any mode gets test results
+        else if (trimmed.length === 1) attachTestResults(trimmed);
+        const note = trimmed.length > 1 ? disambiguationNote(q, trimmed) : undefined;
+        return { results: trimmed, mode: "like", total: trimmed.length, has_more: hasMore, note };
+      }
+    }
+  }
+
+  // 2b. Slug-normalized LIKE: strip all separators from both query and product_url slug.
+  //     Handles concatenated AKAs ("hapax3", "fiberboxplus", "wapaxlte7") and superscript
+  //     queries ("hap ax3" → slug hap_ax3 → stripped hapax3). Anchors to /product/ prefix
+  //     to avoid matching domain or path components.
+  if (q) {
+    const slugQuery = q.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (slugQuery.length >= 5) {
+      const slugPattern = `%/product/%${slugQuery}%`;
+      const slugSql = `${DEVICE_SELECT} d WHERE d.product_url IS NOT NULL AND REPLACE(LOWER(d.product_url), '_', '') LIKE ? ORDER BY d.product_name LIMIT ?`;
+      const slugResults = db.prepare(slugSql).all(slugPattern, limit + 1) as DeviceResult[];
+      if (slugResults.length > 0) {
+        const hasMore = slugResults.length > limit;
+        const trimmed = hasMore ? slugResults.slice(0, limit) : slugResults;
+        if (trimmed.length <= 5) attachTestResults(trimmed);
+        else if (trimmed.length === 1) attachTestResults(trimmed);
+        const note = trimmed.length > 1 ? disambiguationNote(q, trimmed) : undefined;
+        return { results: trimmed, mode: "like", total: trimmed.length, has_more: hasMore, note };
       }
     }
   }
@@ -829,7 +1016,7 @@ export function searchDevices(
     whereClauses.push("d.sim_slots > 0");
   }
 
-  const terms = query ? extractTerms(query) : [];
+  const terms = q ? extractTerms(q) : [];
 
   if (terms.length > 0) {
     // FTS with filters — use prefix matching for device model numbers
@@ -848,9 +1035,13 @@ export function searchDevices(
         WHERE devices_fts MATCH ?${filterWhere}
         ORDER BY rank LIMIT ?`;
       try {
-        const results = db.prepare(sql).all(ftsQuery, ...params, limit) as DeviceResult[];
+        const results = db.prepare(sql).all(ftsQuery, ...params, limit + 1) as DeviceResult[];
         if (results.length > 0) {
-          return { results, mode: "fts", total: results.length };
+          const hasMore = results.length > limit;
+          const trimmed = hasMore ? results.slice(0, limit) : results;
+          // Single FTS match gets test results (same behavior as exact)
+          if (trimmed.length === 1) attachTestResults(trimmed);
+          return { results: trimmed, mode: "fts", total: trimmed.length, has_more: hasMore };
         }
       } catch { /* fall through to OR */ }
 
@@ -858,9 +1049,12 @@ export function searchDevices(
       if (terms.length > 1) {
         const orQuery = buildDeviceFtsQuery(terms, "OR");
         try {
-          const results = db.prepare(sql).all(orQuery, ...params, limit) as DeviceResult[];
+          const results = db.prepare(sql).all(orQuery, ...params, limit + 1) as DeviceResult[];
           if (results.length > 0) {
-            return { results, mode: "fts+or", total: results.length };
+            const hasMore = results.length > limit;
+            const trimmed = hasMore ? results.slice(0, limit) : results;
+            if (trimmed.length === 1) attachTestResults(trimmed);
+            return { results: trimmed, mode: "fts+or", total: trimmed.length, has_more: hasMore };
           }
         } catch { /* fall through */ }
       }
@@ -870,11 +1064,214 @@ export function searchDevices(
   // 4. Filter-only (no FTS query)
   if (whereClauses.length > 0) {
     const sql = `${DEVICE_SELECT} d WHERE ${whereClauses.join(" AND ")} ORDER BY d.product_name LIMIT ?`;
-    const results = db.prepare(sql).all(...params, limit) as DeviceResult[];
-    return { results, mode: "filter", total: results.length };
+    const results = db.prepare(sql).all(...params, limit + 1) as DeviceResult[];
+    const hasMore = results.length > limit;
+    const trimmed = hasMore ? results.slice(0, limit) : results;
+    return { results: trimmed, mode: "filter", total: trimmed.length, has_more: hasMore };
   }
 
-  return { results: [], mode: "fts", total: 0 };
+  return { results: [], mode: "fts", total: 0, has_more: false };
+}
+
+// ── Cross-device test result queries ──
+
+export type DeviceTestRow = {
+  product_name: string;
+  product_code: string | null;
+  architecture: string;
+  test_type: string;
+  mode: string;
+  configuration: string;
+  packet_size: number;
+  throughput_kpps: number | null;
+  throughput_mbps: number | null;
+};
+
+type DeviceTestFilters = {
+  test_type?: string;
+  mode?: string;
+  configuration?: string;
+  packet_size?: number;
+  sort_by?: "mbps" | "kpps";
+};
+
+function buildTestWhereClause(filters: DeviceTestFilters): { whereClause: string; params: (string | number)[] } {
+  const where: string[] = [];
+  const params: (string | number)[] = [];
+
+  if (filters.test_type) {
+    where.push("t.test_type = ?");
+    params.push(filters.test_type);
+  }
+  if (filters.mode) {
+    where.push("t.mode = ?");
+    params.push(filters.mode);
+  }
+  if (filters.configuration) {
+    where.push("t.configuration LIKE ?");
+    params.push(`%${filters.configuration}%`);
+  }
+  if (filters.packet_size) {
+    where.push("t.packet_size = ?");
+    params.push(filters.packet_size);
+  }
+
+  return {
+    whereClause: where.length > 0 ? `WHERE ${where.join(" AND ")}` : "",
+    params,
+  };
+}
+
+export function searchDeviceTests(
+  filters: DeviceTestFilters,
+  limit = 50,
+): { results: DeviceTestRow[]; total: number } {
+  const { whereClause, params } = buildTestWhereClause(filters);
+  const orderCol = filters.sort_by === "kpps" ? "t.throughput_kpps" : "t.throughput_mbps";
+
+  // Total count (before limit)
+  const totalSql = `SELECT COUNT(*) AS c FROM device_test_results t
+    JOIN devices d ON d.id = t.device_id ${whereClause}`;
+  const total = Number((db.prepare(totalSql).get(...params) as { c: number }).c);
+
+  const sql = `SELECT d.product_name, d.product_code, d.architecture,
+      t.test_type, t.mode, t.configuration, t.packet_size,
+      t.throughput_kpps, t.throughput_mbps
+    FROM device_test_results t
+    JOIN devices d ON d.id = t.device_id
+    ${whereClause}
+    ORDER BY ${orderCol} DESC NULLS LAST
+    LIMIT ?`;
+
+  const results = db.prepare(sql).all(...params, limit) as DeviceTestRow[];
+  return { results, total };
+}
+
+type DeviceTestCsvRow = {
+  product_name: string;
+  product_code: string | null;
+  architecture: string | null;
+  cpu: string | null;
+  cpu_cores: number | null;
+  cpu_frequency: string | null;
+  test_type: string;
+  mode: string;
+  configuration: string;
+  packet_size: number;
+  throughput_kpps: number | null;
+  throughput_mbps: number | null;
+  product_url: string | null;
+};
+
+export function exportDeviceTestsCsv(): string {
+  const rows = db.prepare(`SELECT d.product_name, d.product_code, d.architecture,
+      d.cpu, d.cpu_cores, d.cpu_frequency,
+      t.test_type, t.mode, t.configuration, t.packet_size,
+      t.throughput_kpps, t.throughput_mbps,
+      d.product_url
+    FROM device_test_results t
+    JOIN devices d ON d.id = t.device_id
+    ORDER BY d.product_name, t.test_type, t.mode, t.configuration, t.packet_size DESC`).all() as DeviceTestCsvRow[];
+
+  return rowsToCsv(rows, [
+    "product_name",
+    "product_code",
+    "architecture",
+    "cpu",
+    "cpu_cores",
+    "cpu_frequency",
+    "test_type",
+    "mode",
+    "configuration",
+    "packet_size",
+    "throughput_kpps",
+    "throughput_mbps",
+    "product_url",
+  ]);
+}
+
+type DeviceCsvRow = {
+  product_name: string;
+  product_code: string | null;
+  architecture: string | null;
+  cpu: string | null;
+  cpu_cores: number | null;
+  cpu_frequency: string | null;
+  license_level: number | null;
+  operating_system: string | null;
+  ram: string | null;
+  ram_mb: number | null;
+  storage: string | null;
+  storage_mb: number | null;
+  dimensions: string | null;
+  poe_in: string | null;
+  poe_out: string | null;
+  max_power_w: number | null;
+  wireless_24_chains: number | null;
+  wireless_5_chains: number | null;
+  eth_fast: number | null;
+  eth_gigabit: number | null;
+  eth_2500: number | null;
+  sfp_ports: number | null;
+  sfp_plus_ports: number | null;
+  eth_multigig: number | null;
+  usb_ports: number | null;
+  sim_slots: number | null;
+  msrp_usd: number | null;
+  product_url: string | null;
+  block_diagram_url: string | null;
+};
+
+export function exportDevicesCsv(): string {
+  const rows = db.prepare(`${DEVICE_SELECT} ORDER BY product_name`).all() as DeviceCsvRow[];
+
+  return rowsToCsv(rows, [
+    "product_name",
+    "product_code",
+    "architecture",
+    "cpu",
+    "cpu_cores",
+    "cpu_frequency",
+    "license_level",
+    "operating_system",
+    "ram",
+    "ram_mb",
+    "storage",
+    "storage_mb",
+    "dimensions",
+    "poe_in",
+    "poe_out",
+    "max_power_w",
+    "wireless_24_chains",
+    "wireless_5_chains",
+    "eth_fast",
+    "eth_gigabit",
+    "eth_2500",
+    "sfp_ports",
+    "sfp_plus_ports",
+    "eth_multigig",
+    "usb_ports",
+    "sim_slots",
+    "msrp_usd",
+    "product_url",
+    "block_diagram_url",
+  ]);
+}
+
+/** Get distinct values for test result fields (for discovery). */
+export function getTestResultMeta(): {
+  test_types: string[];
+  modes: string[];
+  configurations: string[];
+  packet_sizes: number[];
+} {
+  const col = (sql: string) => (db.prepare(sql).all() as Array<{ v: string }>).map((r) => r.v);
+  return {
+    test_types: col("SELECT DISTINCT test_type AS v FROM device_test_results ORDER BY v"),
+    modes: col("SELECT DISTINCT mode AS v FROM device_test_results ORDER BY v"),
+    configurations: col("SELECT DISTINCT configuration AS v FROM device_test_results ORDER BY v"),
+    packet_sizes: (db.prepare("SELECT DISTINCT packet_size AS v FROM device_test_results ORDER BY v DESC").all() as Array<{ v: number }>).map((r) => r.v),
+  };
 }
 
 const VERSION_CHANNELS = ["stable", "long-term", "testing", "development"] as const;

package/src/setup.ts

@@ -10,7 +10,7 @@
 import { execSync } from "node:child_process";
 import { existsSync, writeFileSync } from "node:fs";
 import { gunzipSync } from "bun";
-import { detectMode, resolveBaseDir, resolveDbPath, resolveVersion } from "./paths.ts";
+import { detectMode, resolveBaseDir, resolveDbPath, resolveVersion, SCHEMA_VERSION } from "./paths.ts";
 
 declare const REPO_URL: string;
 
@@ -84,8 +84,13 @@ export async function runSetup(force = false) {
     const db = new sqlite(dbPath, { readonly: true });
     const row = db.prepare("SELECT COUNT(*) AS c FROM pages").get() as { c: number };
     const cmdRow = db.prepare("SELECT COUNT(*) AS c FROM commands WHERE type='cmd'").get() as { c: number };
+    const versionRow = db.prepare("PRAGMA user_version").get() as { user_version: number };
     db.close();
-    console.log(`✓ Database ready (${row.c} pages, ${cmdRow.c} commands)`);
+    if (versionRow.user_version !== SCHEMA_VERSION) {
+      console.warn(`  Warning: DB schema version is ${versionRow.user_version}, expected ${SCHEMA_VERSION}.`);
+      console.warn(`  The downloaded DB may be incompatible with this version of rosetta.`);
+    }
+    console.log(`✓ Database ready (${row.c} pages, ${cmdRow.c} commands, schema v${versionRow.user_version})`);
   } catch (e) {
     console.error(`✗ Database validation failed: ${e}`);
     const retryCmd = mode === "compiled" ? "rosetta" : mode === "package" ? "bunx @tikoci/rosetta" : "bun run src/setup.ts";