@yottameta/yotta-skills 0.24.2 → 0.25.0

package/lib/agent-dirs.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * Agent skill directory mappings.
+ *
+ * This module is intentionally data-only. It is used by both the installer
+ * CLI and the local discovery/inventory code so a host mapping is defined
+ * once. `resolveUserDir` applies the documented environment overrides.
+ */
+
+const os = require('os');
+const path = require('path');
+
+const AGENT_DIRS = {
+  'aider-desk':      { label: 'AiderDesk',             dirs: ['.aider-desk/skills'] },
+  amp:               { label: 'Amp',                   dirs: ['.config/agents/skills', '.agents/skills'] },
+  antigravity:       { label: 'Antigravity',           dirs: ['.gemini/antigravity/skills', '.agents/skills'] },
+  'antigravity-cli': { label: 'Antigravity CLI',       dirs: ['.gemini/antigravity-cli/skills', '.agents/skills'] },
+  'autohand-code':   { label: 'Autohand Code CLI',     dirs: ['.autohand/skills'] },
+  augment:           { label: 'Augment',               dirs: ['.augment/skills'] },
+  bob:               { label: 'IBM Bob',               dirs: ['.bob/skills'] },
+  claude:            { label: 'Claude Code',           dirs: ['.claude/skills'] },
+  cline:             { label: 'Cline',                 dirs: ['.agents/skills', '.cline/skills'] },
+  codearts:          { label: 'CodeArts Agent',        dirs: ['.codeartsdoer/skills'] },
+  codebuddy:         { label: 'CodeBuddy Code',        dirs: ['.codebuddy/skills'] },
+  codemaker:         { label: 'Codemaker',             dirs: ['.codemaker/skills'] },
+  codestudio:        { label: 'Code Studio',           dirs: ['.codestudio/skills'] },
+  codex:             { label: 'Codex',                 dirs: ['.codex/skills', '.agents/skills'] },
+  'command-code':    { label: 'Command Code',          dirs: ['.commandcode/skills'] },
+  comate:            { label: 'Comate 文心快码',        dirs: ['.comate/skills'] },
+  continue:          { label: 'Continue',              dirs: ['.continue/skills'] },
+  cortex:            { label: 'Cortex Code',           dirs: ['.snowflake/cortex/skills'] },
+  crush:             { label: 'Crush',                 dirs: ['.config/crush/skills'] },
+  cursor:            { label: 'Cursor',                dirs: ['.cursor/skills', '.agents/skills'] },
+  deepagents:        { label: 'Deep Agents',           dirs: ['.deepagents/agent/skills', '.agents/skills'] },
+  devin:             { label: 'Devin for Terminal',    dirs: ['.config/devin/skills'] },
+  droid:             { label: 'Droid',                 dirs: ['.factory/skills', '.agents/skills'] },
+  firebender:        { label: 'Firebender',            dirs: ['.firebender/skills', '.agents/skills'] },
+  forgecode:         { label: 'ForgeCode',             dirs: ['.forge/skills'] },
+  fx:                { label: 'fx',                    dirs: ['.fx/skills'] },
+  gemini:            { label: 'Gemini CLI',            dirs: ['.gemini/skills', '.agents/skills'] },
+  copilot:           { label: 'GitHub Copilot',        dirs: ['.copilot/skills', '.agents/skills'] },
+  goose:             { label: 'Goose',                 dirs: ['.config/goose/skills', '.goose/skills'] },
+  grok:              { label: 'Grok Build',            dirs: ['.grok/skills'] },
+  hermes:            { label: 'Hermes Agent',          dirs: ['.hermes/skills'] },
+  'inference-sh':    { label: 'inference.sh',          dirs: ['.inferencesh/skills'] },
+  jazz:              { label: 'Jazz',                  dirs: ['.jazz/skills'] },
+  junie:             { label: 'Junie',                 dirs: ['.junie/skills'] },
+  iflow:             { label: 'iFlow CLI',             dirs: ['.iflow/skills'] },
+  kilo:              { label: 'Kilo Code',             dirs: ['.kilo/skills', '.agents/skills'] },
+  kimchi:            { label: 'Kimchi',                dirs: ['.config/kimchi/harness/skills'] },
+  kimi:              { label: 'Kimi Code CLI',         dirs: ['.kimi/skills', '.agents/skills'] },
+  kiro:              { label: 'Kiro',                  dirs: ['.kiro/skills'] },
+  kode:              { label: 'Kode',                  dirs: ['.kode/skills'] },
+  lingma:            { label: 'Lingma',                dirs: ['.lingma/skills'] },
+  mcpjam:            { label: 'MCPJam',                dirs: ['.mcpjam/skills'] },
+  minimax:           { label: 'MiniMax Code',          dirs: ['.minimax/skills'] },
+  'mistral-vibe':    { label: 'Mistral Vibe',          dirs: ['.vibe/skills'] },
+  moxby:             { label: 'Moxby',                 dirs: ['.moxby/skills'] },
+  mux:               { label: 'Mux',                   dirs: ['.mux/skills'] },
+  opencode:          { label: 'OpenCode',              dirs: ['.config/opencode/skills', '.agents/skills'] },
+  openhands:         { label: 'OpenHands',             dirs: ['.openhands/skills'] },
+  ona:               { label: 'Ona',                   dirs: ['.ona/skills'] },
+  openclaw:          { label: 'OpenClaw / QClaw',      dirs: ['.openclaw/skills'] },
+  pi:                { label: 'Pi',                    dirs: ['.agents/skills'] },
+  posit:             { label: 'Posit Assistant',       dirs: ['.posit/assistant/skills'] },
+  qoder:             { label: 'Qoder',                 dirs: ['.qoder/skills'] },
+  'qoder-cn':        { label: 'Qoder CN',              dirs: ['.qoder-cn/skills'] },
+  qwen:              { label: 'Qwen Code',             dirs: ['.qwen/skills'] },
+  reasonix:          { label: 'Reasonix',              dirs: ['.reasonix/skills'] },
+  rovodev:           { label: 'Rovo Dev',              dirs: ['.rovodev/skills'] },
+  roo:               { label: 'Roo Code',              dirs: ['.roo/skills'] },
+  'sarvam-code':     { label: 'Sarvam Code',           dirs: ['.sarvam/skills', '.agents/skills'] },
+  tabnine:           { label: 'Tabnine CLI',           dirs: ['.tabnine/agent/skills'] },
+  terramind:         { label: 'Terramind',             dirs: ['.terramind/skills'] },
+  tinycloud:         { label: 'Tinycloud',             dirs: ['.tinycloud/skills'] },
+  trae:              { label: 'Trae Code CLI',         dirs: ['.traecli/skills', '.trae/skills'] },
+  'trae-cn':         { label: 'Trae IDE（国内）',       dirs: ['.trae-cn/skills', '.trae/skills'] },
+  warp:              { label: 'Warp',                  dirs: ['.agents/skills', '.warp/skills'] },
+  windsurf:          { label: 'Windsurf',              dirs: ['.codeium/windsurf/skills', '.windsurf/skills'] },
+  workbuddy:         { label: 'WorkBuddy',             dirs: ['.workbuddy/skills'] },
+  zcode:             { label: 'ZCode',                 dirs: ['.zcode/skills'] },
+  zencoder:          { label: 'Zencoder',              dirs: ['.zencoder/skills'] },
+  neovate:           { label: 'Neovate',               dirs: ['.neovate/skills'] },
+  pochi:             { label: 'Pochi',                 dirs: ['.pochi/skills'] },
+  adal:              { label: 'AdaL',                  dirs: ['.adal/skills'] },
+  dsh:               { label: 'DSH / DeepSeek Harness', dirs: ['.dsh/skills'] },
+  yottacode:         { label: 'YottaCode',             dirs: ['.yottacode/skills'] },
+  box:               { label: 'Box Agent',             dirs: ['.box-agent/skills'] },
+  lmstudio:          { label: 'LM Studio',             dirs: ['.lmstudio/skills'] },
+  ccswitch:          { label: 'CC Switch',             dirs: ['.cc-switch/skills'] },
+  agents:            { label: '通用 AGENTS.md',         dirs: ['.agents/skills'] },
+  universal:         { label: 'Universal .agents',      dirs: ['.agents/skills'] },
+};
+
+function envPath(env, key) {
+  const value = env && env[key];
+  return value ? String(value) : null;
+}
+
+function homeDir(options) {
+  return (options && options.homeDir) || os.homedir();
+}
+
+function envObject(options) {
+  return (options && options.env) || process.env;
+}
+
+/**
+ * Resolve one relative mapping. Environment overrides are intentionally
+ * explicit rather than inferred: if an agent supports a custom home, the
+ * caller must set that agent's documented variable.
+ */
+function resolveUserDir(rel, options) {
+  const home = homeDir(options);
+  const env = envObject(options);
+
+  if (rel === '.codex/skills') {
+    return path.join(envPath(env, 'CODEX_HOME') || path.join(home, '.codex'), 'skills');
+  }
+  if (rel.startsWith('.config/')) {
+    const base = envPath(env, 'XDG_CONFIG_HOME') || path.join(home, '.config');
+    return path.join(base, ...rel.slice('.config/'.length).split('/'));
+  }
+  if (rel === '.openclaw/skills') {
+    return path.join(envPath(env, 'OPENCLAW_STATE_DIR') || path.join(home, '.openclaw'), 'skills');
+  }
+  if (rel === '.claude/skills') {
+    return path.join(envPath(env, 'CLAUDE_CONFIG_DIR') || path.join(home, '.claude'), 'skills');
+  }
+  if (rel === '.hermes/skills') {
+    return path.join(envPath(env, 'HERMES_HOME') || path.join(home, '.hermes'), 'skills');
+  }
+  if (rel === '.vibe/skills') {
+    return path.join(envPath(env, 'VIBE_HOME') || path.join(home, '.vibe'), 'skills');
+  }
+  if (rel === '.grok/skills') {
+    return path.join(envPath(env, 'GROK_HOME') || path.join(home, '.grok'), 'skills');
+  }
+  if (rel === '.autohand/skills') {
+    return path.join(envPath(env, 'AUTOHAND_HOME') || path.join(home, '.autohand'), 'skills');
+  }
+  if (rel === '.sarvam/skills') {
+    return path.join(envPath(env, 'SARVAM_HOME') || path.join(home, '.sarvam'), 'skills');
+  }
+  return path.join(home, rel);
+}
+
+/** All known agent skill directories, including missing ones. */
+function knownRoots(options) {
+  const roots = [];
+  const seen = new Set();
+  const add = (dir, agentId, label) => {
+    if (!dir) return;
+    const resolved = path.resolve(dir);
+    if (seen.has(resolved)) return;
+    seen.add(resolved);
+    roots.push({ dir: resolved, agentId, label, known: true });
+  };
+  for (const [agentId, info] of Object.entries(AGENT_DIRS)) {
+    for (const rel of info.dirs) {
+      add(resolveUserDir(rel, options), agentId, info.label);
+    }
+  }
+  return roots;
+}
+
+/** Additional roots that are commonly used by desktop / portable agents. */
+function envRoots(options) {
+  const env = envObject(options);
+  const roots = [];
+  const add = (dir, agentId, label) => {
+    if (!dir) return;
+    roots.push({ dir: path.resolve(dir), agentId: agentId || null, label: label || '环境变量指定目录', known: false, env: true });
+  };
+
+  add(envPath(env, 'CODEX_HOME') && path.join(env.CODEX_HOME, 'skills'), 'codex', 'Codex（CODEX_HOME）');
+  add(envPath(env, 'XDG_CONFIG_HOME') && path.join(env.XDG_CONFIG_HOME, 'opencode', 'skills'), 'opencode', 'OpenCode（XDG_CONFIG_HOME）');
+  add(envPath(env, 'XDG_STATE_HOME') && path.join(env.XDG_STATE_HOME, 'skills'), null, 'XDG_STATE_HOME/skills');
+  add(envPath(env, 'XDG_DATA_HOME') && path.join(env.XDG_DATA_HOME, 'skills'), null, 'XDG_DATA_HOME/skills');
+  add(envPath(env, 'DSH_HOME') && path.join(env.DSH_HOME, 'skills'), 'dsh', 'DSH（DSH_HOME）');
+  add(envPath(env, 'DSH_AGENTS_HOME') && path.join(env.DSH_AGENTS_HOME, 'skills'), 'dsh', 'DSH Agents（DSH_AGENTS_HOME）');
+  add(envPath(env, 'OPENCLAW_STATE_DIR') && path.join(env.OPENCLAW_STATE_DIR, 'skills'), 'openclaw', 'OpenClaw（OPENCLAW_STATE_DIR）');
+  add(envPath(env, 'CLAUDE_CONFIG_DIR') && path.join(env.CLAUDE_CONFIG_DIR, 'skills'), 'claude', 'Claude Code（CLAUDE_CONFIG_DIR）');
+  add(envPath(env, 'YOTTACODE_HOME') && path.join(env.YOTTACODE_HOME, 'skills'), 'yottacode', 'YottaCode（YOTTACODE_HOME）');
+
+  const extra = String(env.YOTTA_SKILLS_DISCOVERY_ROOTS || '')
+    .split(path.delimiter)
+    .map((item) => item.trim())
+    .filter(Boolean);
+  for (const dir of extra) add(dir, null, 'YOTTA_SKILLS_DISCOVERY_ROOTS');
+
+  return roots;
+}
+
+module.exports = {
+  AGENT_DIRS,
+  resolveUserDir,
+  knownRoots,
+  envRoots,
+};

package/lib/agent-discovery.js

@@ -0,0 +1,302 @@
+'use strict';
+
+/**
+ * Local agent / skill-directory discovery.
+ *
+ * The discovery path is intentionally filesystem-first: it does not read the
+ * memory registry or any YottaMeta state. It combines:
+ *   1. known host mappings + documented environment overrides;
+ *   2. bounded scans of common config / app-data roots;
+ *   3. a lightweight installed-app marker scan for hosts that have no
+ *      conventional skills directory.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const agentDirs = require('./agent-dirs');
+
+const SKILL_FILE = 'SKILL.md';
+const SKIP_DIRS = new Set([
+  '.git', 'node_modules', '__pycache__', '.pytest_cache', '.mypy_cache',
+  '.venv', 'venv', 'site-packages', 'dist', 'build', 'out', 'coverage',
+  'logs', 'log', 'tmp', 'temp', 'cache', '.cache', '.npm', '.cargo',
+  '.rustup', '.nuget', '.gradle', '.m2', '.ssh',
+]);
+const AGENT_HINT = /(agent|claude|cursor|codex|opencode|openclaw|qclaw|trae|qwen|kimi|comate|codebuddy|workbuddy|dsh|deepseek|mimo|yotta|bionic|cherry|teleagent|dumate|cc.?switch|lmstudio|box|hermes|mavis|pi\b)/i;
+const INSTALLED_NOISE = /(uninstall|updater|update|virtualbox|oracle|redistributable|runtime|driver)/i;
+
+function envObject(options) {
+  return (options && options.env) || process.env;
+}
+
+function homeDir(options) {
+  return (options && options.homeDir) || os.homedir();
+}
+
+function isDirectory(dir) {
+  try {
+    return fs.statSync(dir).isDirectory();
+  } catch (_) {
+    return false;
+  }
+}
+
+function safeReaddir(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return [];
+  }
+}
+
+function countSkills(dir) {
+  let count = 0;
+  for (const entry of safeReaddir(dir)) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const child = path.join(dir, entry.name);
+    if (!isDirectory(child)) continue;
+    try {
+      if (fs.statSync(path.join(child, SKILL_FILE)).isFile()) count++;
+    } catch (_) { /* not a standard skill directory */ }
+  }
+  return count;
+}
+
+function normalizePath(dir) {
+  const resolved = path.resolve(dir);
+  try {
+    return fs.realpathSync.native(resolved);
+  } catch (_) {
+    return resolved;
+  }
+}
+
+function isNoisePath(dir, baseDir) {
+  const resolved = path.resolve(dir);
+  const base = baseDir ? path.resolve(baseDir) : null;
+  const relative = base && isInsidePath(base, resolved) ? path.relative(base, resolved) : resolved;
+  const parts = relative.split(/[\\/]+/).filter(Boolean).map((part) => part.toLowerCase());
+  for (const part of parts) {
+    if (part === 'temp' || part === 'tmp') return true;
+    if (/\.bak$/.test(part)) return true;
+    if (part === 'plugin-sources' || part === 'plugins' || part === 'node_modules') return true;
+    if (part === 'candidate' || part.startsWith('candidate-') || part.includes('staging')) return true;
+    if (part === 'memories' || part === 'connectors' || part === 'workspace') return true;
+  }
+  return false;
+}
+
+function isInsidePath(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function addRoot(list, seen, dir, meta) {
+  if (!dir) return;
+  const resolved = path.resolve(dir);
+  const key = normalizePath(resolved).toLowerCase();
+  if (seen.has(key)) {
+    const existing = seen.get(key);
+    if (meta && meta.known && existing) existing.known = true;
+    if (meta && meta.agentId && !existing.agentId) existing.agentId = meta.agentId;
+    if (meta && meta.label && existing.label === '自动发现目录') existing.label = meta.label;
+    return;
+  }
+  const record = {
+    dir: resolved,
+    agentId: (meta && meta.agentId) || null,
+    label: (meta && meta.label) || '自动发现目录',
+    known: Boolean(meta && meta.known),
+    env: Boolean(meta && meta.env),
+    detection: (meta && meta.detection) || 'mapping',
+    exists: isDirectory(resolved),
+  };
+  record.skillCount = record.exists ? countSkills(resolved) : 0;
+  record.status = record.exists ? 'skills-dir' : 'missing';
+  seen.set(key, record);
+  list.push(record);
+}
+
+/**
+ * Bounded recursive scan for directories named "skills".
+ * Only branches that look agent-related are followed after the first level.
+ */
+function scanForSkillDirs(root, options) {
+  const maxDepth = (options && options.maxDepth) || 3;
+  const maxVisits = (options && options.maxVisits) || 6000;
+  const found = [];
+  const queue = [{ dir: path.resolve(root), depth: 0 }];
+  let visits = 0;
+
+  while (queue.length > 0 && visits < maxVisits) {
+    const current = queue.shift();
+    if (!isDirectory(current.dir)) continue;
+    visits++;
+    const entries = safeReaddir(current.dir);
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const full = path.join(current.dir, entry.name);
+      if (/^skills$/i.test(entry.name)) {
+        if (isDirectory(full) && !isNoisePath(full, options && options.baseDir)) found.push({ dir: full, parent: current.dir });
+        continue;
+      }
+      if (current.depth >= maxDepth) continue;
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      if (!isDirectory(full)) continue;
+      const branchLooksRelevant = current.depth === 0
+        || AGENT_HINT.test(entry.name)
+        || AGENT_HINT.test(path.basename(current.dir));
+      if (branchLooksRelevant) queue.push({ dir: full, depth: current.depth + 1 });
+    }
+  }
+  return found;
+}
+
+function commonRoots(options) {
+  const env = envObject(options);
+  const home = homeDir(options);
+  const roots = [];
+  const add = (dir, depth) => {
+    if (!dir) return;
+    roots.push({ dir: path.resolve(dir), maxDepth: depth });
+  };
+
+  add(home, 2);
+  add(env.APPDATA, 3);
+  add(env.LOCALAPPDATA, 3);
+  add(env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, 'Programs'), 3);
+  add(env.ProgramFiles, 2);
+  add(env['ProgramFiles(x86)'], 2);
+  add(env.XDG_CONFIG_HOME, 3);
+  add(env.XDG_STATE_HOME, 3);
+  add(env.XDG_DATA_HOME, 3);
+  add(env.DSH_HOME, 3);
+  add(env.DSH_AGENTS_HOME, 3);
+  add(env.OPENCLAW_STATE_DIR, 2);
+  add(env.CLAUDE_CONFIG_DIR, 2);
+  add(env.CODEX_HOME, 2);
+  add(env.YOTTACODE_HOME, 2);
+
+  // A portable agent install often lives beside the current workspace. The
+  // scanner only follows agent-looking branches, so this stays bounded.
+  if (!options || (options.includeCwd !== false && String(env.YOTTA_SKILLS_DISCOVERY_NO_CWD || '') !== '1')) {
+    let current = path.resolve(process.cwd());
+    for (let depth = 0; depth < 3; depth++) {
+      add(current, 2);
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  return roots;
+}
+
+function collectMarkerNames(root, depth, output, maxEntries) {
+  if (!root || depth < 0 || output.size >= maxEntries) return;
+  for (const entry of safeReaddir(root)) {
+    if (SKIP_DIRS.has(entry.name)) continue;
+    if (/\.lnk$/i.test(entry.name)) {
+      output.add(entry.name.replace(/\.lnk$/i, '').trim());
+      continue;
+    }
+    if (entry.isDirectory() && depth > 0) {
+      collectMarkerNames(path.join(root, entry.name), depth - 1, output, maxEntries);
+    }
+  }
+}
+
+function installedMarkers(options) {
+  const env = envObject(options);
+  const names = new Set();
+  const roots = [
+    env.APPDATA && path.join(env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs'),
+    env.ProgramData && path.join(env.ProgramData, 'Microsoft', 'Windows', 'Start Menu', 'Programs'),
+    env.APPDATA,
+    env.LOCALAPPDATA,
+    env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, 'Programs'),
+    env.ProgramFiles,
+    env['ProgramFiles(x86)'],
+  ];
+  for (const root of roots) collectMarkerNames(root, 2, names, 800);
+  return [...names].filter((name) => AGENT_HINT.test(name) && !INSTALLED_NOISE.test(name));
+}
+
+function knownLabelMatches(name) {
+  const normalized = String(name || '').toLowerCase();
+  for (const info of Object.values(agentDirs.AGENT_DIRS)) {
+    if (normalized.includes(String(info.label).toLowerCase())) return true;
+  }
+  return false;
+}
+
+/**
+ * Discover hosts and their skill directories.
+ *
+ * Returns:
+ *   hosts    - all candidate skill roots (existing and missing known mappings)
+ *   installed - installed app markers, including hosts without a skills dir
+ *   errors   - non-fatal discovery errors
+ */
+function discoverHosts(options) {
+  const roots = [];
+  const seen = new Map();
+  const errors = [];
+
+  for (const root of agentDirs.knownRoots(options)) {
+    addRoot(roots, seen, root.dir, { ...root, detection: 'mapping' });
+  }
+  for (const root of agentDirs.envRoots(options)) {
+    addRoot(roots, seen, root.dir, { ...root, detection: root.env ? 'env' : 'workspace' });
+  }
+  for (const root of commonRoots(options)) {
+    for (const found of scanForSkillDirs(root.dir, {
+      maxDepth: root.maxDepth,
+      baseDir: options.homeDir || os.homedir(),
+    })) {
+      addRoot(roots, seen, found.dir, {
+        detection: 'discovered',
+        label: '自动发现：' + path.basename(found.parent),
+      });
+    }
+  }
+
+  const installed = [];
+  const installedSeen = new Set();
+  const addInstalled = (name, source) => {
+    const label = String(name || '').trim();
+    if (!label) return;
+    const key = label.toLowerCase();
+    if (installedSeen.has(key)) return;
+    installedSeen.add(key);
+    installed.push({ label, source, hasSkillsDir: false });
+  };
+  for (const name of installedMarkers(options)) {
+    if (knownLabelMatches(name) || AGENT_HINT.test(name)) addInstalled(name, '应用标记');
+  }
+  for (const host of roots) {
+    if (!host.exists) continue;
+    addInstalled(host.label, host.known ? '已知宿主' : '自动发现');
+    const item = installed.find((entry) => entry.label.toLowerCase() === String(host.label).toLowerCase());
+    if (item) {
+      item.hasSkillsDir = true;
+      item.skillDir = host.dir;
+      item.skillCount = host.skillCount;
+      item.agentId = host.agentId;
+    }
+  }
+
+  return {
+    generatedAt: new Date().toISOString(),
+    hosts: roots,
+    installed,
+    errors,
+  };
+}
+
+module.exports = {
+  AGENT_HINT,
+  discoverHosts,
+  scanForSkillDirs,
+  countSkills,
+};