dsh-desktop-kit 1.0.0 → 2.0.1

package/plugins/dsh-skill-autopilot/index.js

@@ -0,0 +1,444 @@
+/**
+ * dsh-skill-autopilot — skills that apply themselves.
+ *
+ * The problem: a skill catalog only lists names and descriptions. The model
+ * still has to remember to call `skill`, and when it does it usually loads the
+ * entire body. Both cost tokens and both get skipped under pressure.
+ *
+ * This host plugin reads the current user message on every prompt assembly and
+ * injects a tiny `<skill-autopilot>` context block naming the exact skills that
+ * match the request, with their token prices, plus the rule "load the core
+ * only". No match — no block at all, so an unrelated chat pays zero tokens.
+ *
+ * The matched skill names are filtered against the skills that actually exist
+ * in the DSH home, so a stale rule can never send the model after a missing
+ * skill.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export const inject = ["systemPrompt"];
+
+const STATE_FILE = "dsh-autopilot.json";
+const MAX_HINT_TOKENS = 140;
+const SKILL_CACHE_MS = 60_000;
+
+/* ------------------------------------------------------------------ */
+/* intent rules                                                        */
+/* ------------------------------------------------------------------ */
+
+/**
+ * `any` — at least one substring matches. `all` — every group matches at least
+ * one substring (used only where it removes obvious false positives).
+ * Substrings are compared against lowercased message text.
+ */
+const RULES = [
+  {
+    id: "ui",
+    label: "UI/дизайн",
+    any: ["вёрстк", "верстк", "дизайн", "интерфейс", " ui ", "ux", "лендинг", "страниц", "компонент", "адаптив", "css", "tailwind", "макет", "красив", "темн", "светл", "кнопк", "форм"],
+    skills: ["wow-design", "ui-design-system"],
+    follow: { any: ["критик", "аудит", "оцен", "улучш", "передела"], skills: ["design-critique"] },
+  },
+  {
+    id: "seo",
+    label: "SEO",
+    any: ["seo", "поисков", "мета-тег", "метатег", "title", "description", "schema", "json-ld", "разметк", "индексац", "sitemap", "robots", "яндекс", "google"],
+    skills: ["seo"],
+    follow: { any: ["страниц", "лендинг", "вёрстк", "верстк", "интерфейс"], skills: ["wow-design"] },
+  },
+  {
+    id: "content",
+    label: "Текст/контент",
+    any: ["стать", "пост", "контент", "пресс-релиз", "новост", "заголов", "редакт", "текст для", "написать текст", "объявлен"],
+    skills: ["content-writing"],
+  },
+  {
+    id: "research",
+    label: "Актуальные факты",
+    any: ["актуал", "новост", "цена", "курс", "верси", "закон", "документац", "сравни", "найди в интернете", "последн", "сегодня", "2026", "рынок"],
+    skills: ["web-research"],
+  },
+  {
+    id: "plan",
+    label: "Планирование",
+    any: ["план", "тз", "требован", "декомпоз", "оцен", "архитектур", "вариант", "исследован", "предложи", "концепц"],
+    skills: ["requirements-and-planning", "dev-workflow"],
+  },
+  {
+    id: "debug",
+    label: "Отладка",
+    any: ["ошибк", "баг", "не работает", "падает", "сломал", "стектрейс", "exception", "traceback", "debug", "почему не"],
+    skills: ["debugging-playbook"],
+    follow: { any: ["тест", "проверь"], skills: ["testing-strategy"] },
+  },
+  {
+    id: "db",
+    label: "База данных",
+    any: ["база данных", "postgres", " postgresql", " sql", "миграц", "таблиц", "схем", "бэкап", "pg_dump", "truncate", "данные"],
+    skills: ["database-safety"],
+    follow: { any: ["обновлен", "апгрейд", "upgrade"], skills: ["pg-upgrade-verify"] },
+  },
+  {
+    id: "security",
+    label: "Безопасность",
+    any: ["безопасн", "авториз", "аутентиф", "csrf", "xss", "инъекц", "права доступа", "роли", "секрет", "уязвим"],
+    skills: ["security-review"],
+  },
+  {
+    id: "test",
+    label: "Тесты",
+    any: ["тест", "phpunit", "playwright", "e2e", "покрыт", "регресс", "baseline", "фикстур"],
+    skills: ["testing-strategy"],
+  },
+  {
+    id: "release",
+    label: "Релиз",
+    any: ["релиз", "деплой", "выкат", "publish", "npm pack", "сборк", "артефакт", "откат"],
+    skills: ["release-and-deploy", "git-and-ci"],
+  },
+  {
+    id: "git",
+    label: "Git/CI",
+    any: ["git", "ветк", "коммит", "merge", "rebase", "pull request", " pr ", "ci ", "conflict"],
+    skills: ["git-and-ci"],
+  },
+  {
+    id: "memory",
+    label: "Память проекта",
+    any: ["памят", "досье", "запомни", "project_memory", "журнал", "контекст проекта"],
+    skills: ["project-memory-maintenance", "project-deep-dive"],
+  },
+  {
+    id: "review",
+    label: "Ревью",
+    any: ["ревью", "code review", "review", "аудит код", "проверь код", "чек-лист"],
+    skills: ["code-review-checklist"],
+  },
+  {
+    id: "service-desk",
+    label: "Service Desk",
+    any: ["service desk", "заявк", "гкб", "servicedesk"],
+    skills: ["service-desk-conventions"],
+    follow: { any: ["бд", "миграц", "postgres"], skills: ["service-desk-db-safety"] },
+  },
+  {
+    id: "tokens",
+    label: "Экономия контекста",
+    any: ["токен", "контекст", "расход", "сжат", "compact", "compact", "лимит контекста"],
+    skills: ["context-economy"],
+  },
+  {
+    id: "skills",
+    label: "Навыки",
+    any: ["навык", "скилл", "skill", "skills", "каталог навыков"],
+    skills: ["skills-router", "context-economy"],
+  },
+];
+
+/* ------------------------------------------------------------------ */
+/* small helpers                                                       */
+/* ------------------------------------------------------------------ */
+
+function dshHome() {
+  return process.env.DSH_HOME ?? path.join(os.homedir(), ".dsh");
+}
+
+function readState() {
+  const file = path.join(dshHome(), STATE_FILE);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+    return {
+      mode: parsed?.mode === "off" ? "off" : "on",
+      maxSkills: Number.isFinite(parsed?.maxSkills) ? Math.max(1, Math.min(5, Math.trunc(parsed.maxSkills))) : 3,
+    };
+  } catch {
+    return { mode: process.env.DSH_AUTOPILOT === "off" ? "off" : "on", maxSkills: 3 };
+  }
+}
+
+function writeState(patch) {
+  const next = { ...readState(), ...patch };
+  next.maxSkills = Math.max(1, Math.min(5, Math.trunc(next.maxSkills)));
+  const file = path.join(dshHome(), STATE_FILE);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  } catch {
+    /* best effort */
+  }
+  return next;
+}
+
+function approxTokens(bytes) {
+  return Math.max(40, Math.round(bytes / 3.2));
+}
+
+function formatTokens(tokens) {
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1).replace(".0", "")}k`;
+  return String(tokens);
+}
+
+/** Map of skill name -> approx SKILL.md tokens, cached for a minute. */
+let skillCache = { at: 0, map: new Map() };
+function loadSkillCosts() {
+  const now = Date.now();
+  if (now - skillCache.at < SKILL_CACHE_MS) return skillCache.map;
+  const map = new Map();
+  const directory = path.join(dshHome(), "skills");
+  let entries = [];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const file = path.join(directory, entry.name, "SKILL.md");
+    try {
+      const stat = fs.statSync(file);
+      map.set(entry.name, approxTokens(stat.size));
+    } catch {
+      /* not a skill folder */
+    }
+  }
+  skillCache = { at: now, map };
+  return map;
+}
+
+/** The latest durable user message of a session, read from the surface tail. */
+const lastMessageCache = new Map();
+function latestUserMessage(session) {
+  if (!session) return null;
+  const id = String(session.id);
+  const cached = lastMessageCache.get(id);
+  let lastSeq = 0;
+  try {
+    lastSeq = Number(session.seq) || 0;
+  } catch {
+    lastSeq = 0;
+  }
+  if (cached && cached.seq === lastSeq) return cached.value;
+  let value = null;
+  try {
+    const nodes = session.surface?.nodes ?? [];
+    for (let index = nodes.length - 1; index >= 0; index -= 1) {
+      const event = session.eventAt(nodes[index]);
+      if (!event || event.type !== "user/message") continue;
+      const text = messageText(event.data?.message);
+      if (text.length > 0) {
+        value = { seq: Number(event.seq), text };
+        break;
+      }
+    }
+  } catch {
+    value = null;
+  }
+  lastMessageCache.set(id, { seq: lastSeq, value });
+  return value;
+}
+
+function messageText(message) {
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block && block.type === "text" && typeof block.text === "string") parts.push(block.text);
+  }
+  return parts.join("\n").trim();
+}
+
+function matches(text, needles) {
+  return needles.some((needle) => text.includes(needle));
+}
+
+/** Pick rules and skills for a message. Pure and exported for tests. */
+export function routeMessage(rawText, available = loadSkillCosts(), maxSkills = 3) {
+  const text = ` ${String(rawText ?? "").toLowerCase()} `;
+  if (text.trim().length === 0) return { intents: [], skills: [] };
+  const hits = [];
+  for (const rule of RULES) {
+    if (!matches(text, rule.any)) continue;
+    const names = [...rule.skills];
+    if (rule.follow && matches(text, rule.follow.any)) names.push(...rule.follow.skills);
+    hits.push({ id: rule.id, label: rule.label, names });
+  }
+  if (hits.length === 0) return { intents: [], skills: [] };
+  /* Prefer skills from the most specific (later, rarer) rules? Keep rule order:
+   * it is ordered from the most common task families to the narrow ones. */
+  const ordered = [];
+  const seen = new Set();
+  for (const hit of hits) {
+    for (const name of hit.names) {
+      if (seen.has(name) || !available.has(name)) continue;
+      seen.add(name);
+      ordered.push({ name, tokens: available.get(name) });
+    }
+  }
+  const skills = ordered.sort((left, right) => (right.tokens || 0) - (left.tokens || 0)).slice(0, maxSkills);
+  return { intents: hits.map((hit) => hit.label), skills };
+}
+
+function renderHint(route) {
+  if (route.skills.length === 0) return "";
+  const skillList = route.skills.map((skill) => `${skill.name} ≈${formatTokens(skill.tokens)} токенов`).join(", ");
+  return [
+    "<skill-autopilot>",
+    `Запрос похож на: ${route.intents.join(" + ")}.`,
+    `Загрузи через tool skill только эти ядра: ${skillList}.`,
+    "Это ядра навыков: references внутри них грузи только при реальной необходимости.",
+    "Другие навыки и их references сейчас не нужны — не загружай их «на всякий случай».",
+    "</skill-autopilot>",
+  ].join("\n");
+}
+
+/* ------------------------------------------------------------------ */
+/* plugin                                                              */
+/* ------------------------------------------------------------------ */
+
+export function apply(ctx) {
+  const logger = ctx.logger;
+  const lastMatches = new Map();
+  let lastHintAt = 0;
+
+  const connection = ctx.get("connection");
+  const routeBase = "/api/dsh-skill-autopilot";
+  const namespace = "dsh-skill-autopilot";
+  const sessions = () => ctx.get("sessions");
+
+  function reply(rpcId, value) {
+    return Response.json({ type: "server-response", rpcId, result: { ok: true, value } });
+  }
+  function fail(rpcId, code, message) {
+    return Response.json({ type: "server-response", rpcId, result: { ok: false, error: { code, message } } });
+  }
+
+  if (connection?.fetch?.register) {
+    const stateRoute = {
+      path: `${routeBase}/state`,
+      methods: ["POST"],
+      requestBody: "buffered",
+      fetch: async (request) => {
+        let rpcId = "invalid";
+        try {
+          const body = await request.json();
+          rpcId = typeof body?.rpcId === "string" ? body.rpcId : rpcId;
+          if (body?.method !== `${namespace}/state`) return fail(rpcId, "autopilot/bad-request", "method mismatch");
+          const state = readState();
+          const costs = loadSkillCosts();
+          const skills = [...costs.entries()].map(([name, tokens]) => ({ name, tokens })).sort((a, b) => b.tokens - a.tokens);
+          const matches = [...lastMatches.values()].sort((a, b) => b.at - a.at).slice(0, 5);
+          return reply(rpcId, {
+            ...state,
+            rules: RULES.length,
+            library: {
+              count: skills.length,
+              totalTokens: skills.reduce((sum, skill) => sum + skill.tokens, 0),
+            },
+            skills,
+            lastMatch: matches[0] ?? null,
+            matches,
+          });
+        } catch (error) {
+          return fail(rpcId, "autopilot/internal", String(error));
+        }
+      },
+    };
+    const setRoute = {
+      path: `${routeBase}/set`,
+      methods: ["POST"],
+      requestBody: "buffered",
+      fetch: async (request) => {
+        let rpcId = "invalid";
+        try {
+          const body = await request.json();
+          rpcId = typeof body?.rpcId === "string" ? body.rpcId : rpcId;
+          if (body?.method !== `${namespace}/set`) return fail(rpcId, "autopilot/bad-request", "method mismatch");
+          const payload = body?.payload ?? {};
+          const patch = {};
+          if (payload.mode === "on" || payload.mode === "off") patch.mode = payload.mode;
+          if (Number.isFinite(payload.maxSkills)) patch.maxSkills = payload.maxSkills;
+          const next = writeState(patch);
+          return reply(rpcId, next);
+        } catch (error) {
+          return fail(rpcId, "autopilot/internal", String(error));
+        }
+      },
+    };
+    const testRoute = {
+      path: `${routeBase}/route`,
+      methods: ["POST"],
+      requestBody: "buffered",
+      fetch: async (request) => {
+        let rpcId = "invalid";
+        try {
+          const body = await request.json();
+          rpcId = typeof body?.rpcId === "string" ? body.rpcId : rpcId;
+          if (body?.method !== `${namespace}/route`) return fail(rpcId, "autopilot/bad-request", "method mismatch");
+          const payload = body?.payload ?? {};
+          const route = routeMessage(String(payload.text ?? ""), loadSkillCosts(), readState().maxSkills);
+          return reply(rpcId, { ...route, hint: renderHint(route) });
+        } catch (error) {
+          return fail(rpcId, "autopilot/internal", String(error));
+        }
+      },
+    };
+    for (const route of [stateRoute, setRoute, testRoute]) {
+      ctx.effect(() => connection.fetch.register(route), `skill-autopilot: ${route.path}`);
+    }
+  } else {
+    logger?.debug?.("[skill-autopilot] no connection service; RPC disabled");
+  }
+
+  /* The routing hint itself: recomputed per prompt assembly, empty when idle. */
+  ctx.systemPrompt.context({
+    name: "dsh-desktop-kit:skill-autopilot",
+    order: 132,
+    interpolate: false,
+    required: false,
+    text: (assemblyContext) => {
+      try {
+        if (readState().mode === "off") return "";
+        const agent = assemblyContext?.agent;
+        if (!agent) return "";
+        const session = agent.session ?? sessions()?.get(agent.id);
+        if (!session) return "";
+        if (session.header?.origin === "subagent") return "";
+        const message = latestUserMessage(session);
+        if (!message) return "";
+        const route = routeMessage(message.text, loadSkillCosts(), readState().maxSkills);
+        if (route.skills.length === 0) return "";
+        const hint = renderHint(route);
+        if (hint.length > MAX_HINT_TOKENS * 4) return "";
+        const now = Date.now();
+        lastHintAt = now;
+        lastMatches.set(String(session.id), {
+          sessionId: String(session.id),
+          at: new Date(now).toISOString(),
+          intents: route.intents,
+          skills: route.skills,
+          chars: hint.length,
+        });
+        if (lastMatches.size > 40) {
+          const oldest = [...lastMatches.entries()].sort((a, b) => a[1].at.localeCompare(b[1].at))[0];
+          if (oldest) lastMatches.delete(oldest[0]);
+        }
+        return hint;
+      } catch (error) {
+        logger?.warn?.(`[skill-autopilot] route failed: ${String(error)}`);
+        return "";
+      }
+    },
+  });
+
+  ctx.effect(() => {
+    logger?.info?.(`[skill-autopilot] ${RULES.length} rules, mode=${readState().mode}`);
+    return () => {
+      lastMessageCache.clear();
+      lastMatches.clear();
+    };
+  }, "skill-autopilot: lifecycle");
+}

package/plugins/dsh-skill-autopilot/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "dsh-skill-autopilot",
+  "version": "1.0.0",
+  "description": "Skill autopilot for DSH: reads the current user message and injects a ~80-token routing hint naming the exact skills to load, so skills apply themselves without bloating the context.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}

package/plugins/dsh-token-lab/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dsh-token-lab
+      name: dsh-token-lab