@tikoci/rosetta 0.6.6 → 0.6.8

package/README.md

@@ -298,6 +298,8 @@ The server exposes 16 tools designed to work together — agents start with `rou
 
 Each tool description includes workflow arrows (`→ next_tool`) and empty-result hints so agents chain tools effectively.
 
+The server also exposes **MCP Resources** for bulk data and supplemental content — CSV datasets (`rosetta://datasets/...`), schema documentation (`rosetta://schema...`), and **agent skill guides** (`rosetta://skills/{name}`) from [tikoci/routeros-skills](https://github.com/tikoci/routeros-skills). Skills are community-created, human-reviewed guides served with provenance attribution. See [MANUAL.md](MANUAL.md) for details.
+
 
 ## RTFM for Details
 For additional install options, HTTP transport configuration, data source details, and the database schema, see [MANUAL.md](MANUAL.md).

package/package.json

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

package/src/browse.ts

@@ -27,12 +27,15 @@ import type {
 } from "./query.ts";
 import {
   browseCommands,
+  browseCommandsAtVersion,
   checkCommandVersions,
   diffCommandVersions,
   fetchCurrentVersions,
   getDudePage,
   getPage,
+  getSkill,
   getTestResultMeta,
+  listSkills,
   lookupProperty,
   searchCallouts,
   searchChangelogs,
@@ -200,6 +203,7 @@ type Context =
   | { type: "changelogs"; results: ChangelogResult[] }
   | { type: "videos"; query: string; results: VideoSearchResult[] }
   | { type: "dude"; query: string; results: DudeSearchResult[] }
+  | { type: "skills" }
   | { type: "properties"; query: string; pageId?: number; results: Array<{ name: string; page_id: number; page_title: string }> }
   | { type: "diff" }
   | { type: "vcheck"; path: string };
@@ -240,6 +244,7 @@ function contextLabel(c: Context): string {
     case "changelogs": return "changelogs";
     case "videos": return truncate(`vid: "${c.query}"`, 30);
     case "dude": return truncate(`dude: "${c.query}"`, 30);
+    case "skills": return "skills";
     case "diff": return "diff";
     case "vcheck": return truncate(`vc: ${c.path}`, 30);
   }
@@ -250,12 +255,17 @@ function contextLabel(c: Context): string {
 function renderWelcome(): string {
   const stats = getDbStats();
   const version = resolveVersion(import.meta.dirname);
+  const dbWarning = stats.commands < 1000
+    ? yellow(`⚠ DB has only ${fmt(stats.commands)} commands — use real DB:  --db ~/.rosetta/ros-help.db`)
+    : null;
   const lines = [
     `RouterOS Documentation Browser  ${dim(`v${version}`)}`,
     `${fmt(stats.pages)} pages · ${fmt(stats.properties)} properties · ${fmt(stats.commands)} commands`,
     `${fmt(stats.devices)} devices · ${fmt(stats.callouts)} callouts · ${fmt(stats.ros_versions)} versions`,
     ...(stats.videos > 0 ? [`${fmt(stats.videos)} videos · ${fmt(stats.video_segments)} transcript segments`] : []),
+    ...(stats.skills > 0 ? [`${fmt(stats.skills)} agent skills ${dim("(tikoci — community content)")}`] : []),
     "",
+    ...(dbWarning ? [dbWarning, ""] : []),
     `Type a search query, or ${bold("help")} for commands.`,
   ];
   return box(lines, "rosetta");
@@ -432,6 +442,11 @@ function renderCommandTree(path: string, children: Array<{
   description: string | null;
   page_title: string | null;
   page_url: string | null;
+  dir_role?: string | null;
+  data_type?: string | null;
+  enum_values?: string | null;
+  _arch?: string | null;
+  completion?: Record<string, { style?: string; preference?: number; desc?: string }> | null;
 }>): string {
   const out: string[] = [];
   out.push(`  ${bold(path || "/")}  ${dim(`(${children.length} children)`)}`);
@@ -441,23 +456,58 @@ function renderCommandTree(path: string, children: Array<{
   const cmds = children.filter((c) => c.type === "cmd");
   const args = children.filter((c) => c.type === "arg");
 
+  let globalIdx = 0;
   for (const group of [
-    { items: dirs, icon: "📁", label: "directories" },
-    { items: cmds, icon: "⚡", label: "commands" },
-    { items: args, icon: "  ", label: "arguments" },
+    { items: dirs, icon: "📁" },
+    { items: cmds, icon: "⚡" },
+    { items: args, icon: dim("·") },
   ]) {
     if (group.items.length === 0) continue;
-    for (const c of group.items) {
+    for (let i = 0; i < group.items.length; i++) {
+      const c = group.items[i];
+      globalIdx++;
+      const num = dim(`${String(globalIdx).padStart(3)}  `);
       const icon = group.icon;
       const name = c.type === "dir" ? bold(c.name) : c.name;
-      const desc = c.description ? dim(` — ${truncate(c.description, 50)}`) : "";
+
+      // Build type hint: enum values, data_type, or completion-derived values
+      let typeHint = "";
+      if (c.data_type === "enum" && c.enum_values) {
+        try {
+          const vals = JSON.parse(c.enum_values) as string[];
+          const shown = vals.length > 6 ? `${vals.slice(0, 6).join("|")}|…` : vals.join("|");
+          typeHint = shown;
+        } catch {
+          typeHint = `<${c.data_type}>`;
+        }
+      } else if (c.data_type === "time" || c.data_type === "integer" || c.data_type === "range") {
+        // Already visible via description range — just tag the type
+        typeHint = `<${c.data_type}>`;
+      } else if (c.data_type) {
+        typeHint = `<${c.data_type}>`;
+      } else if (c.completion && Object.keys(c.completion).length > 0) {
+        // No parsed data_type but completion values exist — surface them
+        const keys = Object.keys(c.completion).filter((k) => k !== "");
+        if (keys.length > 0) {
+          const shown = keys.length > 6 ? `${keys.slice(0, 6).join("|")}|…` : keys.join("|");
+          typeHint = shown;
+        }
+      }
+
+      const parts: string[] = [];
+      if (c.description) parts.push(truncate(c.description, 40));
+      if (typeHint) parts.push(typeHint);
+      if (c.dir_role && c.dir_role !== "namespace") parts.push(`[${c.dir_role}]`);
+      const desc = parts.length > 0 ? dim(` — ${parts.join("  ")}`) : "";
+      const archTag = c._arch ? yellow(` [${c._arch}]`) : "";
       const pageLink = c.page_url ? `  ${cyan(link(c.page_url, dim("📄")))}` : "";
-      out.push(`  ${icon} ${name}${desc}${pageLink}`);
+      out.push(`  ${num}${icon} ${name}${desc}${archTag}${pageLink}`);
     }
+    out.push("");
   }
 
-  out.push("");
   const hints: string[] = [
+    `${cyan("[N]")} select`,
     `${cyan("[cmd <child>]")} drill down`,
     `${cyan("[page <id>]")} view linked page`,
     `${cyan("[b]")} back`,
@@ -847,6 +897,8 @@ function renderHelp(): string {
   cmd("changelog [query]", "cl", "Search changelogs (cl 7.22, cl breaking)", "routeros_search_changelogs");
   cmd("videos <query>", "vid", "Search video transcripts", "routeros_search_videos");
   cmd("dude <query>", "", "Search archived Dude wiki docs", "routeros_dude_search");
+  cmd("skills", "", "List agent skill guides", "rosetta://skills");
+  cmd("skill <name>", "", "View a skill guide", "rosetta://skills/{name}");
   cmd("diff <from> <to> [path]", "", "Command tree diff between versions", "routeros_command_diff");
   cmd("vcheck <path>", "vc", "Version range for a command path", "routeros_command_version_check");
   cmd("versions", "ver", "Live-fetch current RouterOS versions", "routeros_current_versions");
@@ -859,6 +911,11 @@ function renderHelp(): string {
   out.push(`  ${dim("Navigation: type a number to select from results.")}`);
   out.push(`  ${dim("After viewing a page, [p] = properties for that page.")}`);
   out.push(`  ${dim("URLs are clickable in supported terminals (iTerm2, etc.).")}`);
+  out.push(`  ${dim("cmd supports @version suffix: cmd /ip/address @7.15")}`);
+  out.push("");
+  out.push(`  ${bold("CLI flags")}`);
+  out.push(`  ${cyan(pad("--db <path>", 26))} ${dim("")} Use a specific database file`);
+  out.push(`  ${cyan(pad("--once", 26))} ${dim("")} Search once and exit (for piping)`);
 
   return out.join("\n");
 }
@@ -998,6 +1055,17 @@ async function dispatch(input: string): Promise<void> {
       return;
     }
 
+    case "skills": {
+      await doListSkills();
+      return;
+    }
+
+    case "skill": {
+      if (!rest) { console.log(dim("  Usage: skill <name>")); return; }
+      await doViewSkill(rest);
+      return;
+    }
+
     case "diff": {
       const diffParts = rest.split(/\s+/);
       if (diffParts.length < 2) {
@@ -1076,6 +1144,38 @@ async function handleNumberSelect(idx: number): Promise<void> {
     }
     return;
   }
+  if (ctx.type === "skills") {
+    const skills = listSkills();
+    if (skills[idx]) {
+      await doViewSkill(skills[idx].name);
+    }
+    return;
+  }
+  if (ctx.type === "commands") {
+    // Re-query and navigate to the Nth child (dirs and cmds drill in; args show inline)
+    const children = browseCommands(ctx.path);
+    const child = children[idx];
+    if (child) {
+      if (child.type === "dir" || child.type === "cmd") {
+        await doCommandTree(child.path);
+      } else {
+        // arg — display its details inline
+        const parts: string[] = [];
+        if (child.description) parts.push(child.description);
+        if (child.data_type) parts.push(`type: ${child.data_type}`);
+        if (child.enum_values) {
+          try { parts.push(`values: ${JSON.parse(child.enum_values).join("|")}`); } catch { /* ignore */ }
+        } else if (child.completion) {
+          const keys = Object.keys(child.completion).filter((k) => k !== "");
+          if (keys.length > 0) parts.push(`values: ${keys.join("|")}`);
+        }
+        console.log(`\n  ${bold(child.name)}  ${dim(`(${child.path})`)}`);
+        if (parts.length > 0) console.log(`  ${parts.join("  ·  ")}`);
+        console.log("");
+      }
+      return;
+    }
+  }
   if (ctx.type === "properties" && ctx.results[idx]) {
     const p = ctx.results[idx];
     await doPage(String(p.page_id));
@@ -1166,23 +1266,58 @@ async function doSearchProperties(query: string): Promise<void> {
 }
 
 async function doCommandTree(path: string): Promise<void> {
-  const normalized = path.startsWith("/") ? path : path ? `/${path}` : "";
-  // If at a page context and no explicit path, try linked command
-  const cmdPath = !path && ctx.type === "page" && (ctx as { commandPath?: string }).commandPath
-    // biome-ignore lint/style/noNonNullAssertion: narrowed by the truthiness check above
-    ? (ctx as { commandPath?: string }).commandPath!
-    : normalized;
-
-  const children = browseCommands(cmdPath);
+  // Extract optional @version suffix: "cmd /ip/address @7.15" or "cmd /ip add @7.20"
+  let version: string | undefined;
+  let pathArg = path;
+  const versionMatch = path.match(/^(.*?)\s*@(\S+)$/);
+  if (versionMatch) {
+    pathArg = versionMatch[1].trim();
+    version = versionMatch[2];
+  }
+
+  let cmdPath: string;
+  if (!pathArg) {
+    if (ctx.type === "page" && (ctx as { commandPath?: string }).commandPath) {
+      // biome-ignore lint/style/noNonNullAssertion: narrowed above
+      cmdPath = (ctx as { commandPath?: string }).commandPath!;
+    } else if (ctx.type === "commands") {
+      cmdPath = ctx.path;
+    } else {
+      cmdPath = "";
+    }
+  } else if (pathArg.startsWith("/")) {
+    cmdPath = pathArg;
+  } else if (ctx.type === "commands") {
+    // Relative segment: "cmd add" at /ip/address → /ip/address/add
+    cmdPath = `${ctx.path}/${pathArg}`;
+  } else {
+    cmdPath = `/${pathArg}`;
+  }
+
+  const children = version
+    ? browseCommandsAtVersion(cmdPath, version)
+    : browseCommands(cmdPath);
+
   if (children.length === 0) {
-    console.log(dim(`  No children at "${cmdPath}".`));
-    // Try as a command version check instead
-    if (cmdPath) {
-      console.log(`  Try: ${cyan("vc")} ${cmdPath}`);
+    // Check if path itself exists as a leaf node
+    const vcResult = cmdPath ? checkCommandVersions(cmdPath) : null;
+    if (vcResult && vcResult.versions.length > 0) {
+      console.log(`  ${bold(cmdPath)}  ${dim("(leaf — no children)")}`);
+      console.log(`  ${dim("First seen:")} ${bold(vcResult.first_seen ?? "?")}  ${dim("Last seen:")} ${bold(vcResult.last_seen ?? "?")}`);
+      console.log(`  ${dim("Present in")} ${bold(String(vcResult.versions.length))} ${dim("versions")}`);
+      if (vcResult.note) console.log(`  ${dim(vcResult.note)}`);
+      console.log(`  ${dim("Try:")} ${cyan("b")} ${dim("to go up,  or")} ${cyan(`s ${cmdPath.split("/").pop() ?? ""}`)} ${dim("to search docs")}`);
+    } else {
+      console.log(dim(`  No results for "${cmdPath}".`));
+      const term = cmdPath.split("/").filter(Boolean).pop() ?? "";
+      if (term) {
+        console.log(`  ${dim("Try:")} ${cyan(`s ${term}`)} ${dim("(search docs)  or")} ${cyan(`vc ${cmdPath}`)} ${dim("(version check)")}`);
+      }
     }
     return;
   }
-  await paged(renderCommandTree(cmdPath, children));
+  const label = version ? `${cmdPath} @${version}` : cmdPath;
+  await paged(renderCommandTree(label, children));
   pushCtx({ type: "commands", path: cmdPath });
 }
 
@@ -1320,6 +1455,54 @@ async function doSearchDude(query: string): Promise<void> {
   pushCtx({ type: "dude", query, results });
 }
 
+async function doListSkills(): Promise<void> {
+  const skills = listSkills();
+  if (skills.length === 0) {
+    console.log(dim("  No skills available. Run: make extract-skills"));
+    return;
+  }
+  const out: string[] = [];
+  out.push(`  ${bold(`${skills.length} Agent Skills`)}  ${dim("(tikoci/routeros-skills — community content)")}`);
+  out.push(`  ${yellow("⚠ AI-generated, human-reviewed. NOT official MikroTik docs.")}`);
+  out.push("");
+  skills.forEach((s, i) => {
+    out.push(`  ${cyan(String(i + 1).padStart(2))}. ${bold(s.name)}  ${dim(`${s.word_count} words, ${s.ref_count} refs`)}`);
+    out.push(`      ${s.description}`);
+  });
+  out.push("");
+  out.push(`  ${dim("Type a number to view, or: skill <name>")}`);
+  await paged(out.join("\n"));
+  pushCtx({ type: "skills" });
+}
+
+async function doViewSkill(name: string): Promise<void> {
+  const skill = getSkill(name);
+  if (!skill) {
+    console.log(dim(`  Skill "${name}" not found. Use 'skills' to list available skills.`));
+    return;
+  }
+  const out: string[] = [];
+  out.push(`  ${yellow("⚠ PROVENANCE: Community content from tikoci/routeros-skills")}`);
+  out.push(`  ${yellow("  NOT official MikroTik documentation. May contain errors.")}`);
+  out.push(`  ${dim(`Source: ${link(skill.source_url)}`)}`);
+  out.push("");
+  out.push(`  ${bold(skill.name)}  ${dim(`${skill.word_count} words`)}`);
+  out.push(`  ${skill.description}`);
+  out.push("");
+  out.push(skill.content);
+  if (skill.references.length > 0) {
+    out.push("");
+    out.push(`  ${bold("Reference Files")}  ${dim(`(${skill.references.length} files)`)}`);
+    out.push("");
+    for (const ref of skill.references) {
+      out.push(`  ${cyan("─")} ${bold(ref.filename)}  ${dim(`${ref.word_count} words`)}`);
+    }
+    out.push("");
+    out.push(`  ${dim("To view a reference: skill <name> refs")}`);
+  }
+  await paged(out.join("\n"));
+}
+
 async function doDiff(from: string, to: string, pathPrefix?: string): Promise<void> {
   const result = diffCommandVersions(from, to, pathPrefix);
   await paged(renderDiff(result));
@@ -1355,7 +1538,14 @@ async function main() {
 
   const args = process.argv.slice(2);
   const onceMode = args.includes("--once");
-  const queryArgs = args.filter((a) => a !== "--once" && a !== "browse");
+  // Filter out --once, browse, and --db <path> so they don't become search queries
+  const dbArgIdx = args.indexOf("--db");
+  const queryArgs = args.filter((a, i) => {
+    if (a === "--once" || a === "browse") return false;
+    if (a === "--db") return false;
+    if (dbArgIdx !== -1 && i === dbArgIdx + 1) return false;
+    return true;
+  });
   const initialQuery = queryArgs.join(" ");
 
   // Welcome banner (only in interactive mode)

package/src/db.ts

@@ -13,6 +13,8 @@
  *   commands         — RouterOS command tree from inspect.json (latest version)
  *   command_versions — junction: which commands exist in which RouterOS versions
  *   ros_versions     — metadata for each extracted RouterOS version
+ *   schema_nodes     — structured command tree from deep-inspect.json (richer desc, arch, completion)
+ *   schema_node_presence — junction: which schema_nodes exist in which versions
  *   devices          — MikroTik product hardware specs from product matrix CSV
  *   devices_fts      — FTS5 over product name, code, architecture, CPU
  *   changelogs       — parsed changelog entries per RouterOS version
@@ -24,6 +26,9 @@
  *   dude_pages       — The Dude documentation pages (archived from wiki.mikrotik.com via Wayback Machine)
  *   dude_pages_fts   — FTS5 over title, path, text, code
  *   dude_images      — screenshot images from The Dude wiki pages
+ *   skills           — agent skill guides (from tikoci/routeros-skills, community content)
+ *   skills_fts       — FTS5 over name, description, content
+ *   skill_references — reference documents for each skill
  */
 
 import sqlite from "bun:sqlite";
@@ -282,6 +287,20 @@ export function initDb() {
     PRIMARY KEY (version, arch)
   );`);
 
+  // Migration: add deep-inspect _meta provenance columns if missing
+  {
+    const rvCols2 = db.prepare("PRAGMA table_info(ros_versions)").all() as Array<{ name: string }>;
+    if (rvCols2.length > 0 && !rvCols2.some((c) => c.name === "api_transport")) {
+      db.run("ALTER TABLE ros_versions ADD COLUMN api_transport TEXT;");
+    }
+    if (rvCols2.length > 0 && !rvCols2.some((c) => c.name === "enrichment_duration_ms")) {
+      db.run("ALTER TABLE ros_versions ADD COLUMN enrichment_duration_ms INTEGER;");
+    }
+    if (rvCols2.length > 0 && !rvCols2.some((c) => c.name === "crash_paths_safe")) {
+      db.run("ALTER TABLE ros_versions ADD COLUMN crash_paths_safe TEXT;");
+    }
+  }
+
   db.run(`CREATE TABLE IF NOT EXISTS command_versions (
     command_path TEXT NOT NULL,
     ros_version  TEXT NOT NULL,
@@ -290,6 +309,53 @@ export function initDb() {
 
   db.run(`CREATE INDEX IF NOT EXISTS idx_cmdver_version ON command_versions(ros_version);`);
 
+  // -- Schema nodes (structured command tree from deep-inspect.json) --
+  //
+  // schema_nodes replaces the flat commands table with richer structure:
+  // parsed desc fields (data_type, enum_values, range), arch tagging,
+  // dir_role classification, and a JSON _attrs catch-all for completion
+  // data and future metadata like _package.
+  //
+  // The `commands` table is regenerated from schema_nodes at import time
+  // by extract-schema.ts — existing queries continue to read `commands`
+  // with zero downstream churn.
+
+  db.run(`CREATE TABLE IF NOT EXISTS schema_nodes (
+    id          INTEGER PRIMARY KEY,
+    path        TEXT NOT NULL,
+    name        TEXT NOT NULL,
+    type        TEXT NOT NULL,
+    parent_id   INTEGER REFERENCES schema_nodes(id),
+    parent_path TEXT,
+    dir_role    TEXT,
+    desc_raw    TEXT,
+    data_type   TEXT,
+    enum_values TEXT,
+    enum_multi  INTEGER,
+    type_tag    TEXT,
+    range_min   TEXT,
+    range_max   TEXT,
+    max_length  INTEGER,
+    _arch       TEXT,
+    _package    TEXT,
+    _attrs      TEXT,
+    page_id     INTEGER REFERENCES pages(id),
+    UNIQUE(path, type)
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sn_parent ON schema_nodes(parent_path);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sn_type ON schema_nodes(type);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sn_path ON schema_nodes(path);`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_sn_page ON schema_nodes(page_id);`);
+
+  db.run(`CREATE TABLE IF NOT EXISTS schema_node_presence (
+    node_id     INTEGER NOT NULL REFERENCES schema_nodes(id),
+    version     TEXT NOT NULL,
+    PRIMARY KEY (node_id, version)
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_snp_version ON schema_node_presence(version);`);
+
   // -- Devices (MikroTik product matrix) --
 
   db.run(`CREATE TABLE IF NOT EXISTS devices (
@@ -547,6 +613,49 @@ export function initDb() {
   );`);
 
   db.run(`CREATE INDEX IF NOT EXISTS idx_dude_images_page ON dude_images(page_id);`);
+
+  // -- Skills (agent guides from tikoci/routeros-skills — community content, NOT official MikroTik docs) --
+
+  db.run(`CREATE TABLE IF NOT EXISTS skills (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    name          TEXT NOT NULL UNIQUE,
+    description   TEXT,
+    content       TEXT NOT NULL,
+    source_repo   TEXT NOT NULL DEFAULT 'tikoci/routeros-skills',
+    source_sha    TEXT,
+    source_url    TEXT,
+    word_count    INTEGER,
+    extracted_at  TEXT
+  );`);
+
+  db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
+    name, description, content,
+    content=skills, content_rowid=id,
+    tokenize='porter unicode61'
+  );`);
+
+  db.run(`CREATE TRIGGER IF NOT EXISTS skills_ai AFTER INSERT ON skills BEGIN
+    INSERT INTO skills_fts(rowid, name, description, content) VALUES (new.id, new.name, new.description, new.content);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS skills_ad AFTER DELETE ON skills BEGIN
+    INSERT INTO skills_fts(skills_fts, rowid, name, description, content) VALUES ('delete', old.id, old.name, old.description, old.content);
+  END;`);
+  db.run(`CREATE TRIGGER IF NOT EXISTS skills_au AFTER UPDATE ON skills BEGIN
+    INSERT INTO skills_fts(skills_fts, rowid, name, description, content) VALUES ('delete', old.id, old.name, old.description, old.content);
+    INSERT INTO skills_fts(rowid, name, description, content) VALUES (new.id, new.name, new.description, new.content);
+  END;`);
+
+  db.run(`CREATE TABLE IF NOT EXISTS skill_references (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_id      INTEGER NOT NULL REFERENCES skills(id),
+    path          TEXT NOT NULL,
+    filename      TEXT NOT NULL,
+    content       TEXT NOT NULL,
+    word_count    INTEGER,
+    UNIQUE(skill_id, path)
+  );`);
+
+  db.run(`CREATE INDEX IF NOT EXISTS idx_skill_refs_skill ON skill_references(skill_id);`);
 }
 
 /**
@@ -596,6 +705,10 @@ export function getDbStats() {
     video_segments: count("SELECT COUNT(*) AS c FROM video_segments"),
     dude_pages: count("SELECT COUNT(*) AS c FROM dude_pages"),
     dude_images: count("SELECT COUNT(*) AS c FROM dude_images"),
+    skills: count("SELECT COUNT(*) AS c FROM skills"),
+    skill_references: count("SELECT COUNT(*) AS c FROM skill_references"),
+    schema_nodes: count("SELECT COUNT(*) AS c FROM schema_nodes"),
+    schema_node_presence: count("SELECT COUNT(*) AS c FROM schema_node_presence"),
     ...(() => {
       // Semantic version sort — SQL MIN/MAX is lexicographic ("7.10" < "7.9")
       const versions = (db.prepare("SELECT DISTINCT version FROM ros_versions").all() as Array<{ version: string }>).map((r) => r.version);