@tikoci/rosetta 0.3.1 → 0.4.1

package/src/query.test.ts

@@ -13,7 +13,7 @@ import { beforeAll, describe, expect, test } from "bun:test";
 process.env.DB_PATH = ":memory:";
 
 // Dynamic imports so the env-var assignment above is visible to db.ts
-const { db, initDb } = await import("./db.ts");
+const { db, initDb, getDbStats } = await import("./db.ts");
 const {
   extractTerms,
   buildFtsQuery,
@@ -25,6 +25,8 @@ const {
   searchChangelogs,
   checkCommandVersions,
   searchDevices,
+  searchDeviceTests,
+  getTestResultMeta,
 } = await import("./query.ts");
 const { parseChangelog } = await import("./extract-changelogs.ts");
 
@@ -69,6 +71,10 @@ beforeAll(() => {
 
   db.run(`INSERT INTO ros_versions (version, channel, extra_packages, extracted_at)
     VALUES ('7.22', 'stable', 0, '2024-01-01T00:00:00Z')`);
+  db.run(`INSERT INTO ros_versions (version, channel, extra_packages, extracted_at)
+    VALUES ('7.9', 'stable', 0, '2023-01-01T00:00:00Z')`);
+  db.run(`INSERT INTO ros_versions (version, channel, extra_packages, extracted_at)
+    VALUES ('7.10.2', 'stable', 0, '2023-06-01T00:00:00Z')`);
 
   db.run(`INSERT INTO commands
     (id, path, name, type, parent_path, page_id, description, ros_version)
@@ -80,6 +86,8 @@ beforeAll(() => {
 
   db.run(`INSERT INTO command_versions (command_path, ros_version)
     VALUES ('/ip/dhcp-server', '7.22')`);
+  db.run(`INSERT INTO command_versions (command_path, ros_version)
+    VALUES ('/ip/dhcp-server', '7.9')`);
 
   // Device fixtures for searchDevices tests
   db.run(`INSERT INTO devices
@@ -87,13 +95,15 @@ beforeAll(() => {
      license_level, operating_system, ram, ram_mb, storage, storage_mb,
      poe_in, poe_out, 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)
+     eth_multigig, usb_ports, sim_slots, msrp_usd,
+     product_url, block_diagram_url)
     VALUES
     ('hAP ax3', 'C53UiG+5HPaxD2HPaxD', 'ARM 64bit', 'IPQ-6010', 4, 'auto (864 - 1800) MHz',
      4, 'RouterOS v7', '1 GB', 1024, '128 MB', 128,
      '802.3af/at', NULL, 2, 2,
      NULL, 4, 1, NULL, NULL,
-     NULL, 1, NULL, 139.00)`);
+     NULL, 1, NULL, 139.00,
+     'https://mikrotik.com/product/hap_ax3', 'https://cdn.mikrotik.com/web-assets/product_files/hap_ax3_123.png')`);
 
   db.run(`INSERT INTO devices
     (product_name, product_code, architecture, cpu, cpu_cores, cpu_frequency,
@@ -161,6 +171,17 @@ beforeAll(() => {
      NULL, 13, NULL, NULL, NULL,
      NULL, NULL, NULL, 369.00)`);
 
+  // Device test results fixtures (hAP ax3 = id 1)
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ethernet', 'Routing', '25 ip filter rules', 512, 755.9, 3096.2)`);
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ethernet', 'Routing', 'none (fast path)', 512, 2332.0, 9551.9)`);
+  db.run(`INSERT INTO device_test_results
+    (device_id, test_type, mode, configuration, packet_size, throughput_kpps, throughput_mbps)
+    VALUES (1, 'ipsec', 'Single tunnel', 'AES-128-CBC + SHA1', 1400, 120.9, 1354.1)`);
+
   // Page 3: a "large" page with sections for TOC testing
   // Text is ~200 chars to keep fixture small, but we'll use max_length=50 to trigger truncation
   db.run(`INSERT INTO pages
@@ -622,8 +643,8 @@ describe("searchCallouts", () => {
 describe("checkCommandVersions", () => {
   test("returns versions for known command path", () => {
     const res = checkCommandVersions("/ip/dhcp-server");
-    expect(res.versions).toEqual(["7.22"]);
-    expect(res.first_seen).toBe("7.22");
+    expect(res.versions).toEqual(["7.9", "7.22"]);
+    expect(res.first_seen).toBe("7.9");
     expect(res.last_seen).toBe("7.22");
   });
 
@@ -783,6 +804,122 @@ describe("searchDevices", () => {
     const res = searchDevices("");
     expect(res.results).toHaveLength(0);
   });
+
+  test("exact match includes test_results", () => {
+    const res = searchDevices("hAP ax3");
+    expect(res.mode).toBe("exact");
+    expect(res.results).toHaveLength(1);
+    const dev = res.results[0];
+    expect(dev.test_results).toBeDefined();
+    expect(dev.test_results!.length).toBe(3);
+    expect(dev.test_results!.some((t) => t.test_type === "ethernet")).toBe(true);
+    expect(dev.test_results!.some((t) => t.test_type === "ipsec")).toBe(true);
+  });
+
+  test("LIKE match with ≤5 results includes test_results", () => {
+    const res = searchDevices("RB1100");
+    expect(res.mode).toBe("like");
+    expect(res.results.length).toBeLessThanOrEqual(5);
+    // RB1100 devices have no test results, but the field should still be populated (empty array)
+    expect(res.results.every((d) => Array.isArray(d.test_results))).toBe(true);
+  });
+
+  test("exact match includes product_url and block_diagram_url", () => {
+    const res = searchDevices("hAP ax3");
+    expect(res.results[0].product_url).toBe("https://mikrotik.com/product/hap_ax3");
+    expect(res.results[0].block_diagram_url).toContain("cdn.mikrotik.com");
+  });
+
+  test("devices without product_url return null", () => {
+    const res = searchDevices("CCR2216-1G-12XS-2XQ");
+    expect(res.results[0].product_url).toBeNull();
+    expect(res.results[0].block_diagram_url).toBeNull();
+  });
+
+  test("has_more is false when all results fit", () => {
+    const res = searchDevices("", { architecture: "ARM 64bit" }, 50);
+    expect(res.has_more).toBe(false);
+  });
+
+  test("has_more is true when results are truncated", () => {
+    // We have multiple devices; limit to 1 with a broad filter
+    const res = searchDevices("", { architecture: "ARM 64bit" }, 1);
+    expect(res.results).toHaveLength(1);
+    expect(res.has_more).toBe(true);
+  });
+
+  test("single FTS match attaches test_results", () => {
+    // "hAP ax3" as FTS should find exactly one match and attach test results
+    const res = searchDevices("hAP ax3");
+    if (res.mode === "exact" || res.results.length === 1) {
+      expect(res.results[0].test_results).toBeDefined();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// searchDeviceTests: cross-device test queries
+// ---------------------------------------------------------------------------
+
+describe("searchDeviceTests", () => {
+  test("returns all test results with no filters", () => {
+    const res = searchDeviceTests({});
+    expect(res.results.length).toBe(3);
+    expect(res.total).toBe(3);
+  });
+
+  test("filters by test_type", () => {
+    const res = searchDeviceTests({ test_type: "ethernet" });
+    expect(res.results.every((r) => r.test_type === "ethernet")).toBe(true);
+    expect(res.results.length).toBe(2);
+  });
+
+  test("filters by test_type and mode", () => {
+    const res = searchDeviceTests({ test_type: "ipsec", mode: "Single tunnel" });
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].configuration).toBe("AES-128-CBC + SHA1");
+  });
+
+  test("configuration uses LIKE matching", () => {
+    const res = searchDeviceTests({ configuration: "25 ip filter" });
+    expect(res.results).toHaveLength(1);
+    expect(res.results[0].configuration).toBe("25 ip filter rules");
+  });
+
+  test("filters by packet_size", () => {
+    const res = searchDeviceTests({ packet_size: 512 });
+    expect(res.results.every((r) => r.packet_size === 512)).toBe(true);
+  });
+
+  test("sorts by mbps descending by default", () => {
+    const res = searchDeviceTests({ test_type: "ethernet" });
+    if (res.results.length >= 2) {
+      const mbps = res.results.map((r) => r.throughput_mbps ?? 0);
+      expect(mbps[0]).toBeGreaterThanOrEqual(mbps[1]);
+    }
+  });
+
+  test("includes device info in results", () => {
+    const res = searchDeviceTests({ test_type: "ethernet" });
+    expect(res.results[0].product_name).toBeDefined();
+    expect(res.results[0].architecture).toBeDefined();
+  });
+
+  test("respects limit", () => {
+    const res = searchDeviceTests({}, 1);
+    expect(res.results).toHaveLength(1);
+    expect(res.total).toBe(3);
+  });
+});
+
+describe("getTestResultMeta", () => {
+  test("returns distinct values", () => {
+    const meta = getTestResultMeta();
+    expect(meta.test_types).toContain("ethernet");
+    expect(meta.test_types).toContain("ipsec");
+    expect(meta.modes).toContain("Routing");
+    expect(meta.packet_sizes).toContain(512);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -943,7 +1080,7 @@ describe("schema", () => {
     const expected = [
       "pages", "properties", "callouts", "sections",
       "commands", "command_versions", "ros_versions",
-      "devices", "changelogs", "schema_migrations",
+      "devices", "device_test_results", "changelogs", "schema_migrations",
     ];
     for (const table of expected) {
       expect(names).toContain(table);
@@ -993,3 +1130,16 @@ describe("schema", () => {
     expect(triggers).toContain("changelogs_au");
   });
 });
+
+// ---------------------------------------------------------------------------
+// getDbStats: version range uses semantic sort (not lexicographic)
+// ---------------------------------------------------------------------------
+
+describe("getDbStats", () => {
+  test("version range is semantically sorted (7.9 < 7.10.2 < 7.22)", () => {
+    const stats = getDbStats();
+    // Fixtures have 7.9, 7.10.2, 7.22 — lexicographic MIN would give "7.10.2", not "7.9"
+    expect(stats.ros_version_min).toBe("7.9");
+    expect(stats.ros_version_max).toBe("7.22");
+  });
+});

package/src/query.ts

@@ -669,6 +669,15 @@ export function browseCommandsAtVersion(
 
 // ── Device lookup and search ──
 
+export type DeviceTestResult = {
+  test_type: string;
+  mode: string;
+  configuration: string;
+  packet_size: number;
+  throughput_kpps: number | null;
+  throughput_mbps: number | null;
+};
+
 export type DeviceResult = {
   id: number;
   product_name: string;
@@ -698,6 +707,9 @@ export type DeviceResult = {
   usb_ports: number | null;
   sim_slots: number | null;
   msrp_usd: number | null;
+  product_url: string | null;
+  block_diagram_url: string | null;
+  test_results?: DeviceTestResult[];
 };
 
 export type DeviceFilters = {
@@ -715,9 +727,29 @@ const DEVICE_SELECT = `SELECT id, product_name, product_code, architecture, cpu,
     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
+    eth_multigig, usb_ports, sim_slots, msrp_usd,
+    product_url, block_diagram_url
   FROM devices`;
 
+/** Get test results for a device by ID. */
+function getDeviceTestResults(deviceId: number): DeviceTestResult[] {
+  return db.prepare(
+    `SELECT test_type, mode, configuration, packet_size,
+            throughput_kpps, throughput_mbps
+     FROM device_test_results
+     WHERE device_id = ?
+     ORDER BY test_type, mode, configuration, packet_size DESC`
+  ).all(deviceId) as DeviceTestResult[];
+}
+
+/** Attach test results to device results (for single/exact lookups). */
+function attachTestResults(devices: DeviceResult[]): DeviceResult[] {
+  for (const dev of devices) {
+    dev.test_results = getDeviceTestResults(dev.id);
+  }
+  return devices;
+}
+
 /** Build FTS5 query for devices — appends prefix '*' to every term.
  *  Model numbers like "RB1100" need prefix matching to find "RB1100AHx4".
  *  No compound term handling (not relevant for device names). */
@@ -732,14 +764,14 @@ export function searchDevices(
   query: string,
   filters: DeviceFilters = {},
   limit = 10,
-): { results: DeviceResult[]; mode: "exact" | "fts" | "like" | "filter" | "fts+or"; total: number } {
+): { results: DeviceResult[]; mode: "exact" | "fts" | "like" | "filter" | "fts+or"; total: number; has_more: boolean } {
   // 1. Try exact match on product_name or product_code
   if (query) {
     const exact = db
       .prepare(`${DEVICE_SELECT} WHERE product_name = ? COLLATE NOCASE OR product_code = ? COLLATE NOCASE`)
       .all(query, query) as DeviceResult[];
     if (exact.length > 0) {
-      return { results: exact, mode: "exact", total: exact.length };
+      return { results: attachTestResults(exact), mode: "exact", total: exact.length, has_more: false };
     }
   }
 
@@ -757,10 +789,17 @@ export function searchDevices(
         () => "(d.product_name 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) {
-        return { results: likeResults, mode: "like", total: likeResults.length };
+        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 (trimmed.length <= 5) attachTestResults(trimmed);
+        // Single match in any mode gets test results
+        else if (trimmed.length === 1) attachTestResults(trimmed);
+        return { results: trimmed, mode: "like", total: trimmed.length, has_more: hasMore };
       }
     }
   }
@@ -807,15 +846,20 @@ export function searchDevices(
           d.ram, d.ram_mb, d.storage, d.storage_mb, d.dimensions, d.poe_in, d.poe_out,
           d.max_power_w, d.wireless_24_chains, d.wireless_5_chains,
           d.eth_fast, d.eth_gigabit, d.eth_2500, d.sfp_ports, d.sfp_plus_ports,
-          d.eth_multigig, d.usb_ports, d.sim_slots, d.msrp_usd
+          d.eth_multigig, d.usb_ports, d.sim_slots, d.msrp_usd,
+          d.product_url, d.block_diagram_url
         FROM devices_fts fts
         JOIN devices d ON d.id = fts.rowid
         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 */ }
 
@@ -823,9 +867,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 */ }
       }
@@ -835,11 +882,98 @@ 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, has_more: false };
+}
+
+// ── Cross-device test result queries ──
+
+export type DeviceTestRow = {
+  product_name: string;
+  product_code: string | null;
+  architecture: string;
+  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;
+};
+
+export function searchDeviceTests(
+  filters: {
+    test_type?: string;
+    mode?: string;
+    configuration?: string;
+    packet_size?: number;
+    sort_by?: "mbps" | "kpps";
+  },
+  limit = 50,
+): { results: DeviceTestRow[]; total: 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);
+  }
+
+  const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+  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, d.cpu,
+      d.cpu_cores, d.cpu_frequency,
+      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 };
+}
 
-  return { results: [], mode: "fts", total: 0 };
+/** 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/release.test.ts

@@ -238,6 +238,7 @@ describe("release.yml", () => {
     expect(src).toContain("extract-properties.ts");
     expect(src).toContain("extract-commands.ts");
     expect(src).toContain("extract-devices.ts");
+    expect(src).toContain("extract-test-results.ts");
     expect(src).toContain("extract-changelogs.ts");
     expect(src).toContain("link-commands.ts");
   });

package/src/setup.ts

@@ -65,6 +65,7 @@ export async function runSetup(force = false) {
   const dbPath = resolveDbPath(import.meta.dirname);
 
   console.log(`rosetta ${RELEASE_VERSION}`);
+  console.log(`  ${link("https://github.com/tikoci/rosetta")}`);
   console.log();
 
   // ── Download DB if needed ──
@@ -301,8 +302,29 @@ function printHttpConfig(startCmd: string) {
   console.log("  For LAN access, replace localhost with the server's IP address.");
   console.log("  Use a reverse proxy (nginx, caddy) for production HTTPS.");
   console.log();
+
+  printMikroTikConfig();
+}
+
+/** Format a clickable terminal hyperlink using OSC 8 escape sequences. */
+function link(url: string, display?: string): string {
+  return `\x1b]8;;${url}\x07${display ?? url}\x1b]8;;\x07`;
 }
 
+function printMikroTikConfig() {
+  console.log("─".repeat(60));
+  console.log("MikroTik /app container (RouterOS 7.22+, x86 or ARM64):");
+  console.log("─".repeat(60));
+  console.log();
+  console.log("  Run directly on your MikroTik router — any MCP client on");
+  console.log("  the network can connect to the URL shown in the router UI.");
+  console.log();
+  console.log("  Requires: container package + device-mode enabled.");
+  console.log(`  See: ${link("https://github.com/tikoci/rosetta#install-on-mikrotik-app", "README — Install on MikroTik")}`);
+  console.log();
+}
+
+
 // Run directly
 if (import.meta.main) {
   const force = process.argv.includes("--force");