@tikoci/rosetta 0.4.2 → 0.4.4

package/src/mcp-http.test.ts

@@ -315,7 +315,7 @@ describe("HTTP transport: session lifecycle", () => {
     expect(serverInfo.name).toBe("rosetta");
   });
 
-  test("tools/list returns all 11 tools after initialization", async () => {
+  test("tools/list returns all 14 tools after initialization", async () => {
     const { sessionId } = await mcpInitialize(server.url);
 
     // Send initialized notification first (required by protocol)
@@ -326,7 +326,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(13);
+    expect(tools.length).toBe(14);
 
     const toolNames = tools.map((t) => t.name).sort();
     expect(toolNames).toContain("routeros_search");
@@ -547,8 +547,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(13);
-    expect(tools2.length).toBe(13);
+    expect(tools1.length).toBe(14);
+    expect(tools2.length).toBe(14);
   });
 
   test("deleting one session does not affect another", async () => {
@@ -570,7 +570,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(13);
+    expect(tools.length).toBe(14);
 
     // Client1 is gone
     const resp = await fetch(server.url, {

package/src/mcp.ts

@@ -6,6 +6,7 @@
  * and browse the command tree.
  *
  * CLI flags (for compiled binary or `bun run src/mcp.ts`):
+ *   browse             Interactive terminal browser (REPL)
  *   --setup [--force]  Download database + print MCP client config
  *   --version          Print version
  *   --help             Print usage
@@ -55,6 +56,7 @@ if (args.includes("--help") || args.includes("-h")) {
   console.log("Usage:");
   console.log("  rosetta              Start MCP server (stdio transport)");
   console.log("  rosetta --http       Start with Streamable HTTP transport");
+  console.log("  rosetta browse       Interactive terminal browser");
   console.log("  rosetta --setup      Download database + print MCP client config");
   console.log("  rosetta --setup --force  Re-download database");
   console.log("  rosetta --version    Print version");
@@ -80,6 +82,13 @@ if (args.includes("--help") || args.includes("-h")) {
 // Wrap in async IIFE — bun build --compile does not support top-level await
 (async () => {
 
+if (args[0] === "browse") {
+  // Strip "browse" from argv so browse.ts only sees flags/queries
+  process.argv.splice(2, 1);
+  await import("./browse.ts");
+  return;
+}
+
 if (args.includes("--setup")) {
   const { runSetup } = await import("./setup.ts");
   await runSetup(args.includes("--force"));
@@ -172,6 +181,7 @@ const {
   getTestResultMeta,
   searchPages,
   searchProperties,
+  searchVideos,
 } = await import("./query.ts");
 
 initDb();
@@ -240,6 +250,7 @@ Workflow — what to do next:
 → routeros_search_properties: find specific properties mentioned in results
 → routeros_search_callouts: find warnings/notes about topics in results
 → routeros_command_tree: browse the command hierarchy for a feature
+→ routeros_search_videos: search MikroTik YouTube video transcripts for tutorials and demos
 
 Tips:
 - Use specific technical terms: "DHCP relay agent" not "how to set up DHCP"
@@ -664,6 +675,56 @@ Coverage depends on which versions were extracted — typically matches ros_vers
   },
 );
 
+// ---- routeros_search_videos ----
+
+server.registerTool(
+  "routeros_search_videos",
+  {
+    description: `Search MikroTik YouTube video transcripts for RouterOS topics.
+
+Searches chapter-level transcript segments from official MikroTik YouTube videos.
+Returns matching segments with video title, URL, chapter name, and an excerpt.
+Auto-caption quality varies — short config snippets may not appear verbatim.
+
+MUM conference talks are excluded (those are long, off-topic lectures).
+Results include the video URL and start timestamp for direct chapter linking.
+
+Useful for: finding tutorial walkthroughs, feature announcements, demo configs,
+and explanations that complement the text documentation.
+
+→ routeros_search: search official text documentation (more precise for property names)
+→ routeros_get_page: read full documentation page for a topic
+→ routeros_search_callouts: find Warnings/Notes embedded in documentation`,
+    inputSchema: {
+      query: z.string().describe("Topic to search for in video transcripts (e.g., 'VLAN trunking', 'BGP route reflection')"),
+      limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .default(5)
+        .optional()
+        .describe("Max results (1–20, default 5)"),
+    },
+  },
+  async ({ query, limit }) => {
+    const results = searchVideos(query, limit ?? 5);
+    if (results.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `No video transcript results for: "${query}"\n\nTry:\n- Broader or simpler search terms\n- routeros_search for official documentation\n- routeros_search_callouts for Notes and Warnings in docs`,
+          },
+        ],
+      };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+    };
+  },
+);
+
 // ---- routeros_command_version_check ----
 
 server.registerTool(

package/src/query.test.ts

@@ -31,8 +31,10 @@ const {
   searchDeviceTests,
   getTestResultMeta,
   normalizeDeviceQuery,
+  searchVideos,
 } = await import("./query.ts");
 const { parseChangelog } = await import("./extract-changelogs.ts");
+const { parseVtt, segmentTranscript } = await import("./extract-videos.ts");
 
 // ---------------------------------------------------------------------------
 // Fixtures: one "DHCP Server" page + one "Firewall Filter" page
@@ -320,6 +322,30 @@ beforeAll(() => {
     VALUES ('7.22', '2026-Mar-09 10:38', 'bridge', 0, 'added local and static MAC synchronization for MLAG', 2)`);
   db.run(`INSERT INTO changelogs (version, released, category, is_breaking, description, sort_order)
     VALUES ('7.22.1', '2026-Apr-01 09:00', 'wifi', 0, 'fixed channel switching for MediaTek access points', 0)`);
+
+  // Video and transcript fixtures for searchVideos tests
+  db.run(`INSERT INTO videos
+    (id, video_id, title, description, channel, upload_date, duration_s, url, has_chapters)
+    VALUES
+    (1, 'abc123', 'RouterOS VLAN Tutorial', 'How to configure VLANs on MikroTik', 'MikroTik', '20240101', 600,
+     'https://www.youtube.com/watch?v=abc123', 1)`);
+  db.run(`INSERT INTO videos
+    (id, video_id, title, description, channel, upload_date, duration_s, url, has_chapters)
+    VALUES
+    (2, 'def456', 'BGP Routing with RouterOS', 'Advanced BGP configuration', 'MikroTik', '20240201', 900,
+     'https://www.youtube.com/watch?v=def456', 0)`);
+  db.run(`INSERT INTO video_segments
+    (id, video_id, chapter_title, start_s, end_s, transcript, sort_order)
+    VALUES
+    (1, 1, 'Introduction', 0, 120, 'Welcome to the VLAN tutorial. In this video we cover VLAN trunking on MikroTik bridge.', 0)`);
+  db.run(`INSERT INTO video_segments
+    (id, video_id, chapter_title, start_s, end_s, transcript, sort_order)
+    VALUES
+    (2, 1, 'Bridge VLAN configuration', 120, 600, 'To set up bridge VLAN filtering enable vlan-filtering on the bridge interface.', 1)`);
+  db.run(`INSERT INTO video_segments
+    (id, video_id, chapter_title, start_s, end_s, transcript, sort_order)
+    VALUES
+    (3, 2, NULL, 0, NULL, 'BGP peering and route reflection allow scalable routing in large networks.', 0)`);
 });
 
 // ---------------------------------------------------------------------------
@@ -1381,6 +1407,7 @@ describe("schema", () => {
       "pages", "properties", "callouts", "sections",
       "commands", "command_versions", "ros_versions",
       "devices", "device_test_results", "changelogs", "schema_migrations",
+      "videos", "video_segments",
     ];
     for (const table of expected) {
       expect(names).toContain(table);
@@ -1389,7 +1416,7 @@ describe("schema", () => {
 
   test("all FTS5 virtual tables exist", () => {
     const names = tableNames();
-    const expected = ["pages_fts", "properties_fts", "callouts_fts", "devices_fts", "changelogs_fts"];
+    const expected = ["pages_fts", "properties_fts", "callouts_fts", "devices_fts", "changelogs_fts", "videos_fts", "video_segments_fts"];
     for (const fts of expected) {
       expect(names).toContain(fts);
     }
@@ -1430,6 +1457,20 @@ describe("schema", () => {
     expect(triggers).toContain("changelogs_au");
   });
 
+  test("content-sync triggers exist for videos", () => {
+    const triggers = triggerNames();
+    expect(triggers).toContain("videos_ai");
+    expect(triggers).toContain("videos_ad");
+    expect(triggers).toContain("videos_au");
+  });
+
+  test("content-sync triggers exist for video_segments", () => {
+    const triggers = triggerNames();
+    expect(triggers).toContain("video_segs_ai");
+    expect(triggers).toContain("video_segs_ad");
+    expect(triggers).toContain("video_segs_au");
+  });
+
   test("PRAGMA user_version matches SCHEMA_VERSION", () => {
     const result = checkSchemaVersion();
     expect(result.ok).toBe(true);
@@ -1450,3 +1491,148 @@ describe("getDbStats", () => {
     expect(stats.ros_version_max).toBe("7.22");
   });
 });
+
+// ---------------------------------------------------------------------------
+// parseVtt: WebVTT parsing (pure function, no DB)
+// ---------------------------------------------------------------------------
+
+describe("parseVtt", () => {
+  const SIMPLE_VTT = `WEBVTT
+Kind: captions
+Language: en
+
+00:00:01.000 --> 00:00:04.000
+Hello and welcome to the VLAN tutorial.
+
+00:00:04.000 --> 00:00:07.000
+Hello and welcome to the VLAN tutorial. Today we will cover trunking.
+
+00:00:07.000 --> 00:00:10.000
+Today we will cover trunking. Let us begin.
+`;
+
+  test("parses cue start times correctly", () => {
+    const cues = parseVtt(SIMPLE_VTT);
+    expect(cues.length).toBeGreaterThan(0);
+    expect(cues[0].start_s).toBe(1);
+  });
+
+  test("deduplicates overlapping auto-caption cues", () => {
+    // Second cue text is suffix of third — only unique segments should survive
+    const cues = parseVtt(SIMPLE_VTT);
+    // All cue texts should be unique (no exact duplicates)
+    const texts = cues.map((c) => c.text);
+    const unique = new Set(texts);
+    expect(unique.size).toBe(texts.length);
+  });
+
+  test("returns empty array for empty input", () => {
+    expect(parseVtt("")).toEqual([]);
+  });
+
+  test("returns empty array for header-only VTT", () => {
+    expect(parseVtt("WEBVTT\nKind: captions\n")).toEqual([]);
+  });
+
+  test("strips HTML tags from cue text", () => {
+    const vtt = `WEBVTT\n\n00:00:01.000 --> 00:00:03.000\n<b>Bold text</b> and <i>italic</i>.\n`;
+    const cues = parseVtt(vtt);
+    expect(cues[0].text).not.toContain("<b>");
+    expect(cues[0].text).toContain("Bold text");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// segmentTranscript: chapter grouping (pure function, no DB)
+// ---------------------------------------------------------------------------
+
+describe("segmentTranscript", () => {
+  const cues = [
+    { start_s: 0, text: "Introduction begins now." },
+    { start_s: 10, text: "This covers the basics." },
+    { start_s: 60, text: "Chapter two starts here." },
+    { start_s: 90, text: "Configuration details follow." },
+  ];
+
+  test("single segment when no chapters provided", () => {
+    const segments = segmentTranscript(cues);
+    expect(segments).toHaveLength(1);
+    expect(segments[0].chapter_title).toBeNull();
+    expect(segments[0].start_s).toBe(0);
+    expect(segments[0].end_s).toBeNull();
+    expect(segments[0].transcript).toContain("Introduction begins now.");
+  });
+
+  test("splits by chapter boundaries", () => {
+    const chapters = [
+      { title: "Introduction", start_time: 0, end_time: 60 },
+      { title: "Configuration", start_time: 60, end_time: 120 },
+    ];
+    const segments = segmentTranscript(cues, chapters);
+    expect(segments).toHaveLength(2);
+    expect(segments[0].chapter_title).toBe("Introduction");
+    expect(segments[1].chapter_title).toBe("Configuration");
+  });
+
+  test("cues are assigned to correct chapters", () => {
+    const chapters = [
+      { title: "Introduction", start_time: 0, end_time: 60 },
+      { title: "Configuration", start_time: 60, end_time: 120 },
+    ];
+    const segments = segmentTranscript(cues, chapters);
+    expect(segments[0].transcript).toContain("Introduction begins now.");
+    expect(segments[0].transcript).not.toContain("Chapter two");
+    expect(segments[1].transcript).toContain("Chapter two starts here.");
+  });
+
+  test("chapter start_s and end_s are set correctly", () => {
+    const chapters = [
+      { title: "Intro", start_time: 0, end_time: 60 },
+      { title: "Body", start_time: 60, end_time: 300 },
+    ];
+    const segments = segmentTranscript(cues, chapters);
+    expect(segments[0].start_s).toBe(0);
+    expect(segments[0].end_s).toBe(60); // next chapter start
+    expect(segments[1].start_s).toBe(60);
+    expect(segments[1].end_s).toBe(300);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// searchVideos: FTS against video_segments_fts (integration, uses fixture DB)
+// ---------------------------------------------------------------------------
+
+describe("searchVideos", () => {
+  test("finds segments matching query", () => {
+    const results = searchVideos("VLAN trunking bridge");
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].title).toBe("RouterOS VLAN Tutorial");
+  });
+
+  test("returns video_id and url", () => {
+    const results = searchVideos("VLAN");
+    expect(results[0].video_id).toBe("abc123");
+    expect(results[0].url).toContain("youtube.com");
+  });
+
+  test("returns chapter_title when available", () => {
+    const results = searchVideos("vlan filtering bridge");
+    const chapterResult = results.find((r) => r.chapter_title !== null);
+    expect(chapterResult).toBeDefined();
+  });
+
+  test("returns null chapter_title for no-chapter video", () => {
+    const results = searchVideos("BGP peering route reflection");
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].chapter_title).toBeNull();
+  });
+
+  test("returns empty array for empty query", () => {
+    expect(searchVideos("")).toEqual([]);
+  });
+
+  test("respects limit parameter", () => {
+    const results = searchVideos("RouterOS", 1);
+    expect(results.length).toBeLessThanOrEqual(1);
+  });
+});

package/src/query.ts

@@ -1429,6 +1429,57 @@ function runChangelogFtsQuery(
   }
 }
 
+// ── Video/transcript search ──
+
+export type VideoSearchResult = {
+  video_id: string;
+  title: string;
+  url: string;
+  upload_date: string | null;
+  chapter_title: string | null;
+  start_s: number;
+  excerpt: string;
+};
+
+/** Search YouTube video transcripts via FTS, joining segment → video metadata. */
+export function searchVideos(query: string, limit = 5): VideoSearchResult[] {
+  const terms = extractTerms(query);
+  if (terms.length === 0) return [];
+
+  let ftsQuery = buildFtsQuery(terms, "AND");
+  if (!ftsQuery) return [];
+  let results = runVideosFtsQuery(ftsQuery, limit);
+
+  // Fallback to OR if AND returns nothing and we have multiple terms
+  if (results.length === 0 && terms.length > 1) {
+    ftsQuery = buildFtsQuery(terms, "OR");
+    results = runVideosFtsQuery(ftsQuery, limit);
+  }
+
+  return results;
+}
+
+function runVideosFtsQuery(ftsQuery: string, limit: number): VideoSearchResult[] {
+  if (!ftsQuery) return [];
+  try {
+    return db
+      .prepare(
+        `SELECT v.video_id, v.title, v.url, v.upload_date,
+                vs.chapter_title, vs.start_s,
+                snippet(video_segments_fts, 1, '**', '**', '...', 25) as excerpt
+         FROM video_segments_fts fts
+         JOIN video_segments vs ON vs.id = fts.rowid
+         JOIN videos v ON v.id = vs.video_id
+         WHERE video_segments_fts MATCH ?
+         ORDER BY rank
+         LIMIT ?`,
+      )
+      .all(ftsQuery, limit) as VideoSearchResult[];
+  } catch {
+    return [];
+  }
+}
+
 // ── Current versions ──
 
 const VERSION_BASE_URL = "https://upgrade.mikrotik.com/routeros/NEWESTa7";

package/src/release.test.ts

@@ -190,6 +190,18 @@ describe("Makefile", () => {
     expect(makefile).toContain("release:");
   });
 
+  test("has extract-videos target", () => {
+    expect(makefile).toContain("extract-videos:");
+  });
+
+  test("extract-videos is in PHONY", () => {
+    // PHONY uses line continuation; check block before first blank line after .PHONY
+    const phonyStart = makefile.indexOf(".PHONY:");
+    const phonyEnd = makefile.indexOf("\n\n", phonyStart);
+    const phonyBlock = makefile.slice(phonyStart, phonyEnd);
+    expect(phonyBlock).toContain("extract-videos");
+  });
+
   test("release depends on preflight", () => {
     expect(makefile).toMatch(/^release:.*preflight/m);
   });