@vltpkg/cli-js 1.4.0 → 1.6.0

package/skills-KA2VR5Q5.js

@@ -0,0 +1,480 @@
+var global = globalThis;
+import {Buffer} from "node:buffer";
+import {setTimeout as _vlt_setTimeout,clearTimeout as _vlt_clearTimeout,setImmediate as _vlt_setImmediate,clearImmediate as _vlt_clearImmediate,setInterval as _vlt_setInterval,clearInterval as _vlt_clearInterval} from "node:timers";
+globalThis.setTimeout = _vlt_setTimeout;
+globalThis.clearTimeout = _vlt_clearTimeout;
+globalThis.setImmediate = _vlt_setImmediate;
+globalThis.clearImmediate = _vlt_clearImmediate;
+globalThis.setInterval = _vlt_setInterval;
+globalThis.clearInterval = _vlt_clearInterval;
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  editGitignore,
+  filterNodesByQueryParts,
+  load2 as load,
+  lstat,
+  mountSkill,
+  norm,
+  packageKey,
+  readMounts,
+  realOr,
+  samePath,
+  skillsDirs,
+  unmountSkill,
+  unshare
+} from "./chunk-F5LZMLAQ.js";
+import "./chunk-YTDABXPD.js";
+import {
+  Monorepo
+} from "./chunk-TQQO2F56.js";
+import {
+  splitDepID
+} from "./chunk-CAV7FKWQ.js";
+import "./chunk-6D3QAFNZ.js";
+import "./chunk-HTOTG4TS.js";
+import "./chunk-GEQFMH5M.js";
+import "./chunk-B6RIGNEO.js";
+import "./chunk-XNLSTHDK.js";
+import "./chunk-Y5PA7DVK.js";
+import {
+  parse
+} from "./chunk-BF5DRGRZ.js";
+import "./chunk-WZWDS3W4.js";
+import "./chunk-PZLD7RTK.js";
+
+// ../../src/graph/src/skills/index.ts
+import { existsSync } from "node:fs";
+
+// ../../src/graph/src/skills/discover.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var skillDirName = /^[a-z0-9][a-z0-9._-]*$/i;
+var specName = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var topKey = /^([A-Za-z0-9_-]+):/;
+var blockIndicator = /^[>|][-+1-9]*$/;
+var fold = (inline, more) => {
+  let value = [blockIndicator.test(inline) ? "" : inline, ...more].filter(Boolean).join(" ");
+  const q = value[0];
+  if (value.length > 1 && (q === '"' || q === "'") && value.endsWith(q)) {
+    value = value.slice(1, -1).trim();
+  }
+  return value || void 0;
+};
+var readFrontmatter = (file) => {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return {};
+  }
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  const end = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+  if (end === -1) return {};
+  const fm = {};
+  let key;
+  let inline = "";
+  let more = [];
+  const flush = () => {
+    if (key) fm[key] = fold(inline, more);
+    key = void 0;
+  };
+  for (const line of lines.slice(1, end)) {
+    if (!line.trim()) continue;
+    const m = topKey.exec(line);
+    if (m) {
+      flush();
+      const k = m[1];
+      if (k === "name" || k === "description") {
+        key = k;
+        inline = line.slice(k.length + 1).trim();
+        const hash = inline.search(/(?:^|\s)#/);
+        if (hash !== -1 && !/^["']/.test(inline)) {
+          inline = inline.slice(0, hash).trim();
+        }
+        more = [];
+      }
+    } else if (/^\s/.test(line)) {
+      if (key) more.push(line.trim());
+    } else {
+      flush();
+    }
+  }
+  flush();
+  return fm;
+};
+var sanitize = (s) => {
+  const clean = s?.replace(/\p{Cc}/gu, " ").replace(/\s+/g, " ").trim();
+  return clean ? clean.slice(0, 1024) : void 0;
+};
+var lc = (s) => s.toLowerCase();
+var isDir = (path) => !!lstat(path)?.isDirectory();
+var isFile = (path) => !!lstat(path)?.isFile();
+var isSkillMd = (name) => name.toLowerCase() === "skill.md";
+var shipDirs = ["skills", "dist/skills", ".agents/skills"];
+var subdir = (dir, sub) => {
+  let path = dir;
+  for (const seg of sub.split("/")) {
+    path = resolve(path, seg);
+    if (!isDir(path)) return void 0;
+  }
+  return path;
+};
+var scan = (dir, pkgName) => {
+  const found = [];
+  const has = (skill) => found.some((f) => lc(f.skill) === lc(skill));
+  const root = resolve(dir, "SKILL.md");
+  if (isFile(root)) {
+    const { name, description } = readFrontmatter(root);
+    const skill = name && name.length <= 64 && specName.test(name) ? name : pkgName.slice(pkgName.lastIndexOf("/") + 1);
+    if (skillDirName.test(skill) && !isSkillMd(skill)) {
+      found.push({ skill, path: dir, name, description });
+    }
+  }
+  for (const sub of shipDirs) {
+    const skillsDir = subdir(dir, sub);
+    if (!skillsDir) continue;
+    for (const d of readdirSync(skillsDir).sort()) {
+      if (!skillDirName.test(d) || isSkillMd(d) || has(d)) continue;
+      const path = resolve(skillsDir, d);
+      const file = resolve(path, "SKILL.md");
+      if (!isDir(path) || !isFile(file)) continue;
+      const { name, description } = readFrontmatter(file);
+      found.push({ skill: d, path, name, description });
+    }
+  }
+  return found;
+};
+var rank = (node) => {
+  if (node.importer) return 0;
+  let r = 2;
+  for (const { from } of node.edgesIn) {
+    if (from.mainImporter) return 0;
+    if (from.importer) r = 1;
+  }
+  return r;
+};
+var ver = (node) => node.version ? parse(node.version) : void 0;
+var byVersion = (a, b) => {
+  const va = ver(a);
+  const vb = ver(b);
+  return va && vb ? vb.compare(va) : 0;
+};
+var compare = (a, b) => rank(a) - rank(b) || byVersion(a, b) || a.id.localeCompare(b.id, "en");
+var aliasOf = (node) => {
+  const edges = [...node.edgesIn];
+  const n = (edges.find((e) => e.from.mainImporter) ?? edges.find((e) => e.from.importer))?.name;
+  return n === node.name ? void 0 : n;
+};
+var scannable = (node) => node.importer ? !node.mainImporter : node.inVltStore() && splitDepID(node.id)[0] !== "file";
+var shipsSkills = (node) => scannable(node) && scan(realOr(resolve(node.projectRoot, node.location)), node.name).length > 0;
+var discoverSkills = (nodes, scurry, mounts = []) => {
+  const key = (name, path) => `${lc(name)}\0${norm(path)}`;
+  const linkedIn = /* @__PURE__ */ new Map();
+  for (const m of mounts) {
+    const k = key(m.name, realOr(m.target));
+    const dirs = linkedIn.get(k) ?? [];
+    if (!dirs.includes(m.dir.dir)) dirs.push(m.dir.dir);
+    linkedIn.set(k, dirs);
+  }
+  const scanned = /* @__PURE__ */ new Map();
+  const byPkg = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!scannable(node)) continue;
+    const found = scan(
+      realOr(node.resolvedLocation(scurry)),
+      node.name
+    );
+    scanned.set(
+      node.id,
+      found.map(({ skill, path }) => ({ skill, path }))
+    );
+    const key2 = packageKey(node.id);
+    const list = byPkg.get(key2) ?? [];
+    list.push({ node, found });
+    byPkg.set(key2, list);
+  }
+  const rows = [];
+  for (const list of byPkg.values()) {
+    const { node, found } = list.reduce(
+      (a, b) => compare(a.node, b.node) <= 0 ? a : b
+    );
+    for (const { skill, path, name, description } of found) {
+      const fm = sanitize(name);
+      rows.push([
+        {
+          name: node.name,
+          alias: aliasOf(node),
+          version: node.version,
+          id: node.id,
+          skill,
+          ...fm && lc(fm) !== lc(skill) && { frontmatterName: fm },
+          description: sanitize(description),
+          path,
+          linked: linkedIn.get(key(skill, path)) ?? []
+        },
+        rank(node)
+      ]);
+    }
+  }
+  const skills = rows.sort(
+    ([a, ra], [b, rb]) => lc(a.skill).localeCompare(lc(b.skill), "en") || ra - rb || a.id.localeCompare(b.id, "en")
+  ).map(([s]) => s);
+  return { skills, scanned };
+};
+
+// ../../src/graph/src/skills/mask.ts
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var globRegExp = (pattern) => new RegExp(`^${pattern.split("*").map(escape).join(".*")}$`, "i");
+var matches = (re, s) => re.test(s.skill) || !!s.frontmatterName && re.test(s.frontmatterName);
+var maskSkills = (skills, parts) => {
+  const compiled = parts.map((p) => ({
+    keys: new Set([...p.ids].map(packageKey)),
+    patterns: p.patterns?.map((pattern) => ({
+      pattern,
+      re: globRegExp(pattern)
+    }))
+  }));
+  const picked = skills.filter(
+    (s) => compiled.some(
+      (p) => p.keys.has(packageKey(s.id)) && (!p.patterns || p.patterns.some(({ re }) => matches(re, s)))
+    )
+  );
+  const unmatched = [];
+  for (const p of compiled) {
+    if (!p.patterns) continue;
+    const own = skills.filter((s) => p.keys.has(packageKey(s.id)));
+    for (const { pattern, re } of p.patterns) {
+      if (own.some((s) => matches(re, s))) continue;
+      unmatched.push({
+        pattern,
+        ...p.keys.size > 0 && {
+          skills: [...new Set(own.map((s) => s.skill))].sort(
+            (a, b) => a.localeCompare(b, "en")
+          )
+        }
+      });
+    }
+  }
+  return { skills: picked, unmatched };
+};
+
+// ../../src/graph/src/skills/index.ts
+var lc2 = (s) => s.toLowerCase();
+var selectNodes = async (o) => {
+  const graph = o.graph ?? load({ ...o, loadManifests: true });
+  const { ids, parts, unscanned } = await filterNodesByQueryParts(
+    graph,
+    o.target ?? "*"
+  );
+  const nodes = [...graph.nodes.values()].filter((n) => ids.has(n.id));
+  return { graph, nodes, parts, unscanned };
+};
+var dirsOf = (o, create = false) => skillsDirs({
+  projectRoot: o.projectRoot,
+  configured: o.skillsDirs,
+  env: o.env,
+  create
+});
+var workspaceDirs = (graph, scurry) => [...graph.importers].filter((n) => !n.mainImporter).map((n) => ({
+  id: n.id,
+  path: realOr(n.resolvedLocation(scurry))
+}));
+var allWorkspaces = (m) => m ? [
+  ...Monorepo.load(m.projectRoot, {
+    config: m.config,
+    scurry: m.scurry,
+    packageJson: m.packageJson
+  }).values()
+].map((ws) => ({ id: ws.id, path: realOr(ws.fullpath) })) : [];
+var liveOwners = (mounts) => mounts.flatMap(
+  (m) => m.owner && existsSync(m.target) ? [m.owner] : []
+);
+var unshareSkills = async (graph, ids, scurry) => {
+  for (const id of new Set(ids)) {
+    const node = graph.nodes.get(id);
+    if (node?.inVltStore())
+      await unshare(node.resolvedLocation(scurry));
+  }
+};
+var label = (s) => {
+  const pkg = s.version ? `${s.name}@${s.version}` : s.name;
+  return s.alias ? `${s.alias} (${pkg})` : pkg;
+};
+var pick = (found, parts, unscanned) => {
+  const { skills: masked, unmatched } = maskSkills(found, parts);
+  const ok = (s) => !unscanned?.ids.has(s.id);
+  const picked = masked.filter(ok);
+  const names = new Set(picked.map((s) => lc2(s.skill)));
+  const dropped = masked.filter(
+    (s) => !ok(s) && !names.has(lc2(s.skill))
+  );
+  return { skills: found.filter(ok), picked, unmatched, dropped };
+};
+var report = (dropped, unscanned) => unscanned && dropped.length ? {
+  unscanned: dropped.map((s) => `${s.skill} (${label(s)})`),
+  unscannedReason: unscanned.reason
+} : {};
+var listSkills = async (o) => {
+  const { graph, nodes, parts, unscanned } = await selectNodes(o);
+  const { targets, scan: scan2, skipped } = dirsOf(o);
+  const { skills } = discoverSkills(
+    nodes,
+    o.scurry,
+    readMounts(scan2, { workspaces: workspaceDirs(graph, o.scurry) })
+  );
+  const { picked, dropped } = pick(skills, parts, unscanned);
+  return {
+    project: graph.mainImporter.name,
+    graph,
+    skills: picked,
+    dirs: targets.map((d) => d.dir),
+    ...skipped.length ? { skipped } : null,
+    ...report(dropped, unscanned)
+  };
+};
+var linkSkills = async (o) => {
+  const { graph, nodes, parts, unscanned } = await selectNodes(o);
+  const { skills: found, scanned } = discoverSkills(nodes, o.scurry);
+  const { skills, picked, unmatched, dropped } = pick(
+    found,
+    parts,
+    unscanned
+  );
+  const inMask = new Set(picked);
+  const { targets, scan: scan2, skipped } = dirsOf(o, picked.length > 0);
+  const res = {
+    linked: [],
+    unchanged: [],
+    removed: [],
+    conflicts: [],
+    dirs: targets.map((d) => d.dir)
+  };
+  const workspaces = workspaceDirs(graph, o.scurry);
+  const mounts = readMounts(scan2, { workspaces });
+  const byName = new Map(
+    mounts.map((m) => [`${m.dir.dir}\0${lc2(m.name)}`, m])
+  );
+  const stale = (m) => !m.owner || !graph.nodes.has(m.owner) || !existsSync(m.target) || scanned.get(m.owner)?.some(
+    (f) => lc2(f.skill) === lc2(m.name) && samePath(f.path, m.target)
+  ) === false;
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of skills) {
+    const k = lc2(s.skill);
+    groups.set(k, [...groups.get(k) ?? [], s]);
+  }
+  const at = (dir, k, group) => {
+    const m = byName.get(`${dir.dir}\0${k}`);
+    const key = m?.owner && packageKey(m.owner);
+    return { m, own: group.find((s) => packageKey(s.id) === key) };
+  };
+  const cands = (group) => group.filter((s) => inMask.has(s));
+  const first = new Map(
+    [...groups].map(([k, group]) => {
+      const c = cands(group);
+      return [
+        k,
+        targets.map((d) => at(d, k, c).own).find((s) => !!s) ?? c[0]
+      ];
+    })
+  );
+  const isTarget = new Set(targets);
+  const picks = [];
+  for (const dir of scan2) {
+    for (const [k, group] of groups) {
+      const { m, own } = at(dir, k, group);
+      if (isTarget.has(dir)) {
+        const winner = o.apply ? first.get(k) : own ?? (m && !stale(m) ? void 0 : first.get(k));
+        picks.push({
+          dir,
+          winner,
+          losers: cands(group).filter((s) => s !== winner),
+          m
+        });
+      } else if (own && !o.apply) {
+        picks.push({ dir, winner: own, losers: [], m });
+      }
+    }
+  }
+  await unshareSkills(
+    graph,
+    [
+      ...picks.flatMap(({ winner }) => winner ? [winner.id] : []),
+      ...liveOwners(mounts)
+    ],
+    o.scurry
+  );
+  const gone = [];
+  const foreign = [];
+  const kept = /* @__PURE__ */ new Set();
+  const made = /* @__PURE__ */ new Set();
+  const where = /* @__PURE__ */ new Map();
+  let every;
+  for (const { dir, winner, losers, m } of picks) {
+    if (winner) {
+      if (m && m.name !== winner.skill) {
+        unmountSkill(m);
+        gone.push(m);
+      }
+      const mount = `${dir.dir}/${winner.skill}`;
+      const r = mountSkill(winner, dir, m?.name === winner.skill);
+      if (r === "linked") made.add(mount);
+      if (r === "conflict") {
+        res.conflicts.push(mount);
+        every ??= allWorkspaces(o.monorepo);
+        if (!readMounts([dir], { workspaces: every }).some(
+          (l) => l.name === winner.skill
+        )) {
+          foreign.push({ dir, name: winner.skill });
+        }
+      } else {
+        const k = `${winner.id}\0${winner.skill}`;
+        const linked = where.get(k) ?? [];
+        linked.push(dir.dir);
+        where.set(k, linked);
+        res[r].push({ ...winner, linked, dir: dir.dir, mount });
+        kept.add(mount);
+      }
+    }
+    for (const s of losers)
+      res.conflicts.push(`${dir.dir}/${s.skill} (${label(s)})`);
+  }
+  const after = readMounts(scan2, { workspaces, made });
+  const present = [];
+  for (const m of after) {
+    if (o.apply ? kept.has(m.mount) : !stale(m)) {
+      present.push(m);
+      continue;
+    }
+    unmountSkill(m);
+    gone.push(m);
+    res.removed.push(m.mount);
+  }
+  const gitignore = [];
+  for (const dir of scan2) {
+    const add = present.filter((m) => m.dir === dir).map((m) => m.name);
+    const remove = [...gone, ...foreign].filter((m) => m.dir === dir && !add.includes(m.name)).map((m) => m.name);
+    if ((add.length || remove.length) && editGitignore(dir.real, { add, remove }) === "refused") {
+      gitignore.push(`${dir.dir}/.gitignore`);
+    }
+  }
+  if (skipped.length) res.skipped = skipped;
+  if (gitignore.length) res.gitignore = gitignore;
+  if (unmatched.length) res.unmatched = unmatched;
+  const left = dropped.filter(
+    (s) => !targets.every(
+      (d) => present.some(
+        (m) => m.dir === d && m.owner === s.id && lc2(m.name) === lc2(s.skill)
+      )
+    )
+  );
+  return Object.assign(res, report(left, unscanned));
+};
+export {
+  discoverSkills,
+  linkSkills,
+  listSkills,
+  readFrontmatter,
+  shipsSkills
+};