@tikoci/rosetta 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tikoci/rosetta",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "RouterOS documentation as SQLite FTS5 — RAG search + command glossary via MCP",
   "type": "module",
   "license": "MIT",

package/src/db.ts

@@ -345,10 +345,6 @@ export function initDb() {
 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"),
@@ -363,8 +359,27 @@ export function getDbStats() {
     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"),
+    ...(() => {
+      // Semantic version sort — SQL MIN/MAX is lexicographic ("7.10" < "7.9")
+      const versions = (db.prepare("SELECT version FROM ros_versions").all() as Array<{ version: string }>).map((r) => r.version);
+      if (versions.length === 0) return { ros_version_min: null, ros_version_max: null };
+      const norm = (v: string) => {
+        const clean = v.replace(/beta\d*/, "").replace(/rc\d*/, "");
+        const parts = clean.split(".").map(Number);
+        const suffix = v.includes("beta") ? 0 : v.includes("rc") ? 1 : 2;
+        return { parts, suffix };
+      };
+      const cmp = (a: string, b: string) => {
+        const na = norm(a), nb = norm(b);
+        for (let i = 0; i < Math.max(na.parts.length, nb.parts.length); i++) {
+          const d = (na.parts[i] ?? 0) - (nb.parts[i] ?? 0);
+          if (d !== 0) return d;
+        }
+        return na.suffix - nb.suffix;
+      };
+      versions.sort(cmp);
+      return { ros_version_min: versions[0], ros_version_max: versions[versions.length - 1] };
+    })(),
     doc_export: "2026-03-25 (Confluence HTML)",
   };
 }

package/src/mcp-http.test.ts

@@ -212,7 +212,7 @@ describe("HTTP transport: session lifecycle", () => {
 
     const result = (messages[0] as Record<string, unknown>).result as Record<string, unknown>;
     const tools = result.tools as Array<{ name: string }>;
-    expect(tools.length).toBe(11);
+    expect(tools.length).toBe(12);
 
     const toolNames = tools.map((t) => t.name).sort();
     expect(toolNames).toContain("routeros_search");
@@ -402,8 +402,8 @@ describe("HTTP transport: multi-session", () => {
     const tools1 = ((msgs1[0] as Record<string, unknown>).result as Record<string, unknown>).tools as unknown[];
     const tools2 = ((msgs2[0] as Record<string, unknown>).result as Record<string, unknown>).tools as unknown[];
 
-    expect(tools1.length).toBe(11);
-    expect(tools2.length).toBe(11);
+    expect(tools1.length).toBe(12);
+    expect(tools2.length).toBe(12);
   });
 
   test("deleting one session does not affect another", async () => {
@@ -425,7 +425,7 @@ describe("HTTP transport: multi-session", () => {
     // Client2 still works
     const msgs = await mcpRequest(server.url, client2.sessionId, "tools/list", 2);
     const tools = ((msgs[0] as Record<string, unknown>).result as Record<string, unknown>).tools as unknown[];
-    expect(tools.length).toBe(11);
+    expect(tools.length).toBe(12);
 
     // Client1 is gone
     const resp = await fetch(server.url, {

package/src/mcp.ts

@@ -138,6 +138,8 @@ const {
   searchCallouts,
   searchChangelogs,
   searchDevices,
+  searchDeviceTests,
+  getTestResultMeta,
   searchPages,
   searchProperties,
 } = await import("./query.ts");
@@ -672,6 +674,7 @@ Shows bus topology and per-port bandwidth limits — useful for understanding So
 - SMIPS: lowest-end (hAP lite)
 
 Workflow — combine with other tools:
+→ routeros_search_tests: cross-device performance ranking (all 125 devices at once, e.g., 512B routing benchmark)
 → routeros_search: find documentation for features relevant to a device
 → routeros_command_tree: check commands available for a feature
 → routeros_current_versions: check latest firmware for the device
@@ -757,6 +760,115 @@ Data: 144 products, March 2026 snapshot. Not all MikroTik products ever made —
   },
 );
 
+// ---- routeros_search_tests ----
+
+server.registerTool(
+  "routeros_search_tests",
+  {
+    description: `Query device performance test results across all devices.
+
+Returns throughput benchmarks from mikrotik.com product pages — one call replaces
+what would otherwise require 125+ individual device lookups.
+
+**Data:** 2,874 test results across 125 devices (March 2026).
+- Ethernet: bridging/routing throughput at 64/512/1518 byte packets
+- IPSec: tunnel throughput with AES/SHA cipher configurations
+- Results include kpps (packets/sec) and Mbps
+
+**Common queries:**
+- Routing performance ranking: test_type="ethernet", mode="Routing", configuration="25 ip filter rules", packet_size=512
+- Bridge performance: test_type="ethernet", mode="Bridging", configuration="25 bridge filter"
+- IPSec throughput: test_type="ipsec", mode="Single tunnel", configuration="AES-128-CBC"
+
+**Configuration matching:** Uses LIKE (substring) — "25 ip filter" matches "25 ip filter rules".
+Note: some devices use slightly different names (e.g., "25 bridge filter" vs "25 bridge filter rules").
+
+**Tip:** Call with no filters first to see available test_types, modes, configurations, and packet_sizes via the metadata field.
+
+Workflow:
+→ routeros_device_lookup: get full specs + block diagram for a specific device from results
+→ routeros_search: find documentation about features relevant to the test type`,
+    inputSchema: {
+      test_type: z
+        .string()
+        .optional()
+        .describe("Filter: 'ethernet' or 'ipsec'"),
+      mode: z
+        .string()
+        .optional()
+        .describe("Filter: e.g., 'Routing', 'Bridging', 'Single tunnel', '256 tunnels'"),
+      configuration: z
+        .string()
+        .optional()
+        .describe("Filter (substring match): e.g., '25 ip filter rules', 'AES-128-CBC + SHA1', 'none (fast path)'"),
+      packet_size: z
+        .number()
+        .int()
+        .optional()
+        .describe("Filter: packet size in bytes (64, 512, 1400, 1518)"),
+      sort_by: z
+        .enum(["mbps", "kpps"])
+        .optional()
+        .default("mbps")
+        .describe("Sort results by throughput metric (default: mbps)"),
+      limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .default(50)
+        .describe("Max results (default 50, max 200)"),
+    },
+  },
+  async ({ test_type, mode, configuration, packet_size, sort_by, limit }) => {
+    const hasFilters = test_type || mode || configuration || packet_size;
+
+    if (!hasFilters) {
+      // Discovery mode: return available filter values
+      const meta = getTestResultMeta();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            message: "No filters provided. Here are the available values — use these to build your query:",
+            ...meta,
+            hint: "Common query: test_type='ethernet', mode='Routing', configuration='25 ip filter rules', packet_size=512",
+          }, null, 2),
+        }],
+      };
+    }
+
+    const result = searchDeviceTests(
+      { test_type, mode, configuration, packet_size, sort_by },
+      limit,
+    );
+
+    if (result.results.length === 0) {
+      const hints = [
+        "Call with no filters to see available test types, modes, and configurations",
+        configuration ? `Try a shorter configuration substring (e.g., "25 ip filter" instead of the full string)` : null,
+      ].filter(Boolean);
+      return {
+        content: [{
+          type: "text",
+          text: `No test results matched the filters.\n\nTry:\n${hints.map((h) => `- ${h}`).join("\n")}`,
+        }],
+      };
+    }
+
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          ...result,
+          has_more: result.total > result.results.length,
+        }, null, 2),
+      }],
+    };
+  },
+);
+
 // ---- routeros_current_versions ----
 
 server.registerTool(

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
@@ -635,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");
   });
 
@@ -827,6 +835,91 @@ describe("searchDevices", () => {
     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);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -1037,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

@@ -764,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: attachTestResults(exact), mode: "exact", total: exact.length };
+      return { results: attachTestResults(exact), mode: "exact", total: exact.length, has_more: false };
     }
   }
 
@@ -789,12 +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) {
+        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);
+        return { results: trimmed, mode: "like", total: trimmed.length, has_more: hasMore };
       }
     }
   }
@@ -848,9 +853,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 +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 */ }
       }
@@ -870,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 };
+  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 };
+}
+
+/** 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;