@tikoci/rosetta 0.4.0 → 0.4.2

package/src/mcp.ts

@@ -99,7 +99,7 @@ const { z } = await import("zod/v3");
 //
 // Check if DB has data BEFORE importing db.ts. If empty/missing,
 // auto-download so db.ts opens the real database.
-const { resolveDbPath } = await import("./paths.ts");
+const { resolveDbPath, SCHEMA_VERSION } = await import("./paths.ts");
 const _dbPath = resolveDbPath(import.meta.dirname);
 
 const _pageCount = (() => {
@@ -126,18 +126,50 @@ if (_pageCount === 0) {
   }
 }
 
+// Check schema version — a bunx auto-update may bring a new code version whose
+// schema is incompatible with the existing ~/.rosetta/ros-help.db.
+// MUST be checked before importing db.ts, because initDb() stamps user_version.
+const _dbSchemaVersion = (() => {
+  try {
+    const check = new (require("bun:sqlite").default)(_dbPath, { readonly: true });
+    const row = check.prepare("PRAGMA user_version").get() as { user_version: number };
+    check.close();
+    return row.user_version;
+  } catch {
+    return SCHEMA_VERSION; // unreadable — assume ok, initDb() will stamp it
+  }
+})();
+
+if (_dbSchemaVersion !== SCHEMA_VERSION) {
+  const { downloadDb } = await import("./setup.ts");
+  const log = (msg: string) => process.stderr.write(`${msg}\n`);
+  log(`DB schema version mismatch (DB=${_dbSchemaVersion}, expected=${SCHEMA_VERSION}) — re-downloading updated database...`);
+  try {
+    await downloadDb(_dbPath, log);
+    log("Database updated successfully.");
+  } catch (e) {
+    log(`Auto-download failed: ${e}`);
+    log(`Run: ${process.argv[0]} --setup --force`);
+  }
+}
+
 // Now import db.ts (opens the DB) and query.ts
 const { getDbStats, initDb } = await import("./db.ts");
 const {
   browseCommands,
   browseCommandsAtVersion,
   checkCommandVersions,
+  diffCommandVersions,
+  exportDevicesCsv,
+  exportDeviceTestsCsv,
   fetchCurrentVersions,
   getPage,
   lookupProperty,
   searchCallouts,
   searchChangelogs,
   searchDevices,
+  searchDeviceTests,
+  getTestResultMeta,
   searchPages,
   searchProperties,
 } = await import("./query.ts");
@@ -153,6 +185,40 @@ const server = new McpServer({
   version: RESOLVED_VERSION,
 });
 
+server.registerResource(
+  "device-test-results-csv",
+  "rosetta://datasets/device-test-results.csv",
+  {
+    title: "Device Test Results CSV",
+    description: "Full joined benchmark dataset as CSV for reporting and bulk export. Attach explicitly in clients that support MCP resources.",
+    mimeType: "text/csv",
+  },
+  async () => ({
+    contents: [{
+      uri: "rosetta://datasets/device-test-results.csv",
+      mimeType: "text/csv",
+      text: exportDeviceTestsCsv(),
+    }],
+  }),
+);
+
+server.registerResource(
+  "devices-csv",
+  "rosetta://datasets/devices.csv",
+  {
+    title: "Devices CSV",
+    description: "Full device catalog as CSV, including normalized RAM and storage fields plus product and block diagram URLs.",
+    mimeType: "text/csv",
+  },
+  async () => ({
+    contents: [{
+      uri: "rosetta://datasets/devices.csv",
+      mimeType: "text/csv",
+      text: exportDevicesCsv(),
+    }],
+  }),
+);
+
 // ---- routeros_search ----
 
 server.registerTool(
@@ -633,6 +699,67 @@ Examples:
   },
 );
 
+// ---- routeros_command_diff ----
+
+server.registerTool(
+  "routeros_command_diff",
+  {
+    description: `Diff two RouterOS versions — which command paths were added or removed between them.
+
+The most common RouterOS support query is "something broke after I upgraded." This tool
+directly answers it by comparing the command tree between any two tracked versions.
+
+Returns added[] (new in to_version) and removed[] (gone from to_version) with counts.
+Use path_prefix to scope the diff to a subsystem (e.g., '/ip/firewall' or '/routing/bgp').
+
+Command data covers 7.9–7.23beta2. Both versions must be in this range for complete results;
+if a version is outside the range, a note warns that results may be incomplete.
+
+**Typical workflow for upgrade breakage:**
+1. routeros_command_diff from_version="7.15" to_version="7.22" path_prefix="/ip/firewall"
+   → see which filter/mangle/nat commands changed
+2. routeros_search_changelogs from_version="7.15" to_version="7.22" category="firewall"
+   → read human-readable changelog entries for that subsystem
+3. routeros_command_version_check for a specific path that looks suspicious
+   → confirm exact version range for that command
+
+**path_prefix tip:** Start broad (e.g., '/routing/bgp'), then narrow if the diff is large.
+Without a prefix, a major-version diff can list hundreds of added paths.
+
+→ routeros_search_changelogs: read what changed (descriptions, breaking flags)
+→ routeros_command_version_check: check a specific command's full version history
+→ routeros_command_tree: browse the current command hierarchy at a path`,
+    inputSchema: {
+      from_version: z
+        .string()
+        .describe("The older RouterOS version to diff from (e.g., '7.15', '7.9')"),
+      to_version: z
+        .string()
+        .describe("The newer RouterOS version to diff to (e.g., '7.22', '7.23beta2')"),
+      path_prefix: z
+        .string()
+        .optional()
+        .describe("Optional: scope the diff to a command subtree (e.g., '/ip/firewall', '/routing/bgp', '/interface/bridge')"),
+    },
+  },
+  async ({ from_version, to_version, path_prefix }) => {
+    const result = diffCommandVersions(from_version, to_version, path_prefix);
+    if (result.added_count === 0 && result.removed_count === 0) {
+      const hint = [
+        result.note ?? null,
+        "No differences found. Possible reasons:",
+        "- Both versions have identical command trees for this path",
+        "- One or both versions may not be in our tracked range (7.9–7.23beta2)",
+        "Use routeros_stats to see available version range, or try a different path_prefix.",
+      ].filter(Boolean).join("\n");
+      return { content: [{ type: "text", text: hint }] };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+  },
+);
+
 // ---- routeros_device_lookup ----
 
 server.registerTool(
@@ -672,6 +799,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 +885,118 @@ 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.
+
+Results include product_name, product_code, architecture — use routeros_device_lookup for full specs (CPU, RAM, ports, etc.).
+For bulk export/reporting, attach the MCP resource rosetta://datasets/device-test-results.csv in clients that support MCP resources.
+
+Workflow:
+→ routeros_device_lookup: get full specs (CPU, RAM, pricing) + block diagram for a specific device
+→ 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/paths.ts

@@ -73,6 +73,14 @@ export function detectMode(srcDir: string): InvocationMode {
   return "package";
 }
 
+/**
+ * Schema version for ros-help.db.
+ * Increment when making destructive schema changes (DROP/RENAME table or column).
+ * Stamped into the DB via `PRAGMA user_version` by initDb() and checked at MCP
+ * startup to detect stale DBs for bunx users who auto-update the package.
+ */
+export const SCHEMA_VERSION = 1;
+
 /**
  * Resolve the version string.
  * Compiled mode: injected at build time via --define.