@sealant/mend 0.15.2 → 0.16.0

package/README.md

@@ -83,6 +83,10 @@ mend sessions [--all] [--project p] [--json]
 mend status                           active sessions (alias of mend sessions)
 mend pair [--url <base url>]          pair a phone or a second machine: QR + code + URL
 mend doctor                           read-only checklist of this machine's setup
+mend skills [--project [p]]           your skill library on the server (or a project's)
+mend skills push [--project [p]] [--prune] [--dir <path>]
+                                      upload ~/.agents/skills bundles; sessions receive
+                                      them at launch (--prune removes what's gone)
 ```
 
 ## Signing in

package/dist/main.js

@@ -12,6 +12,7 @@ import { loginCommand } from "./login.js";
 import { pairCommand, qrCommand } from "./pair.js";
 import { isComposeFile, proposeFromCompose, proposeFromPackageJson, proposeFromWorkspacePackage, renderMendToml, workspaceGlobs, } from "./service-init.js";
 import { agentIsLive, agentOutcome, cwdFacts, gitTopLevel, HARNESS_COMMANDS, isDetachChunk, LIVE_STATUSES, sessionDisplayName, matchProjectByCwd, normalizeProjectName, gitCurrentBranch, parseLaunchArgs, } from "./shared.js";
+import { DEFAULT_SKILLS_DIR, scanSkillLibrary } from "./skills.js";
 import { sshCommand } from "./ssh-setup.js";
 // `$XDG_CONFIG_HOME/mend`, default `~/.config/mend`; a pre-XDG `~/.mend` stays authoritative
 // when it is the only one present (mirrors @mend/store's resolver — the CLI stays dependency-light).
@@ -1789,6 +1790,75 @@ const dotfilesCommand = async (config, args) => {
             return fail(`unknown dotfiles command "${verb}" — try: mend dotfiles sync | show`);
     }
 };
+/** With `--project` the project's library; bare, your own. */
+const skillsList = async (config, args) => {
+    const forProject = args.includes("--project");
+    const project = forProject ? await findProject(config, takeFlagValue(args, "--project")) : null;
+    const skills = await api(config, "GET", project === null ? "/skills" : `/projects/${project.id}/skills`);
+    const library = project === null ? "your library" : project.name;
+    if (skills.length === 0) {
+        say(dim(`no skills in ${library} — push a local one: mend skills push`));
+        return;
+    }
+    for (const skill of skills) {
+        say(`  ${skill.name.padEnd(28)} ${dim(`${skill.fileCount} file${skill.fileCount === 1 ? "" : "s"} · ${formatDotfileBytes(skill.bytes)}`)}`);
+        if (skill.description !== "")
+            say(`    ${dim(skill.description)}`);
+    }
+};
+/**
+ * Scan the shared agent-skills directory (`~/.agents/skills` by convention)
+ * and upload every bundle. The upload is the intent: same-named skills are
+ * replaced, and `--prune` removes what the directory no longer carries.
+ */
+const skillsPush = async (config, args) => {
+    const dirFlag = takeFlagValue(args, "--dir");
+    const root = dirFlag === null ? path.join(os.homedir(), DEFAULT_SKILLS_DIR) : path.resolve(dirFlag);
+    const scanned = scanSkillLibrary(root);
+    if ("error" in scanned)
+        return fail(scanned.error);
+    for (const note of scanned.notes)
+        say(dim(`  ${note.skill}: ${note.message}`));
+    if (scanned.skills.length === 0)
+        return fail(`no skills found under ${root}`);
+    const forProject = args.includes("--project");
+    const project = forProject ? await findProject(config, takeFlagValue(args, "--project")) : null;
+    const report = await api(config, "POST", "/skills/sync", {
+        scope: project === null ? "user" : "project",
+        projectId: project?.id ?? null,
+        skills: scanned.skills.map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+            files: skill.files,
+        })),
+        prune: args.includes("--prune"),
+    });
+    const library = project === null ? "your library" : project.name;
+    const counts = [
+        `${report.created.length} new`,
+        `${report.updated.length} updated`,
+        `${report.unchanged.length} unchanged`,
+        ...(report.removed.length > 0 ? [`${report.removed.length} removed`] : []),
+    ].join(" · ");
+    say(`${green("pushed")} ${scanned.skills.length} skill${scanned.skills.length === 1 ? "" : "s"} from ${root} to ${library} · ${dim(counts)}`);
+    say(dim("sessions receive them from the next launch"));
+};
+const skillsCommand = async (config, args) => {
+    const [verb, ...rest] = args;
+    switch (verb) {
+        case "push":
+            return skillsPush(config, rest);
+        case "list":
+            return skillsList(config, rest);
+        case undefined:
+            return skillsList(config, args);
+        default:
+            // Bare flags (`mend skills --project web`) read as the list.
+            if (verb.startsWith("--"))
+                return skillsList(config, args);
+            return fail(`unknown skills command "${verb}" — try: mend skills push | list`);
+    }
+};
 // ─── completions: live sessions under TAB ───────────────────────────────────
 /**
  * The data half of shell completion: one live session per line as
@@ -1824,6 +1894,7 @@ _mend() {
     'shell:open a shell in a live session workspace'
     'service:reachable ports — add, list, stop'
     'keys:the machine Mend deploy key — init, show, share'
+    'skills:skill libraries — list, push'
     'accounts:your connected accounts on the platform'
     'pair:pair a phone or a second machine' 'doctor:read-only checklist of this setup'
     'connect:send this machine'"'"'s claude/codex/github credential to the platform'
@@ -1849,7 +1920,7 @@ _mend "$@"
 const BASH_COMPLETIONS = `_mend() {
   local cur=\${COMP_WORDS[COMP_CWORD]}
   if [ "$COMP_CWORD" -eq 1 ]; then
-    COMPREPLY=( $(compgen -W "adopt codex claude opencode run attach stop shell service keys pair doctor continue resume rejoin refresh projects sessions status ui help" -- "$cur") )
+    COMPREPLY=( $(compgen -W "adopt codex claude opencode run attach stop shell service keys skills pair doctor continue resume rejoin refresh projects sessions status ui help" -- "$cur") )
     return
   fi
   case \${COMP_WORDS[1]} in
@@ -2475,6 +2546,10 @@ everything else
   mend accounts                         your connected accounts on the platform (claude, codex, github)
   mend dotfiles                         your dotfiles on the server: repo + synced home files
   mend dotfiles sync [--all | paths…]   capture config files from THIS machine into your store
+  mend skills [--project [p]]           your skill library on the server (or a project's)
+  mend skills push [--project [p]] [--prune] [--dir <path>]
+                                        upload ~/.agents/skills bundles into the library; sessions
+                                        receive them at launch (--prune removes what's gone)
   mend keys share                       relay THIS machine's ssh-agent to the server (bridge mode:
                                         hardware keys sign here; Ctrl-C stops sharing)
   mend run -- <command...>              same, with an arbitrary command
@@ -2545,6 +2620,8 @@ const main = async () => {
             return keysCommand(config, rest);
         case "dotfiles":
             return dotfilesCommand(config, rest);
+        case "skills":
+            return skillsCommand(config, rest);
         case "accounts":
             return accountsCommand(config);
         case "connect":

package/dist/skills.js

@@ -0,0 +1,134 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Local skill-library scanning for `mend skills push`. Runs on the machine
+ * that HAS the skills: the shared agent-skills convention keeps them under
+ * `~/.agents/skills/<name>/SKILL.md` (plus support files), and the CLI
+ * captures the bundles here and streams them to the server's library. The
+ * CLI stays dependency-light by design, so the frontmatter peek below is a
+ * few lines of string handling, not a YAML parser — the server re-validates
+ * everything.
+ */
+/** Where the shared convention keeps user skills, relative to `$HOME`. */
+export const DEFAULT_SKILLS_DIR = ".agents/skills";
+/** The servers' caps, checked here so a mistake fails before the upload. */
+export const MAX_SKILL_FILES = 64;
+export const MAX_SKILL_FILE_BYTES = 512 * 1024;
+const IGNORED_DIRS = new Set([".git", "node_modules", "__pycache__"]);
+const isTextBuffer = (buffer) => !buffer.subarray(0, 8192).includes(0);
+/**
+ * Pull `description:` out of a SKILL.md frontmatter block. Single-line plain
+ * or quoted scalars only — the common case by far; anything else reads as
+ * absent and the server keeps an empty description.
+ */
+export const readFrontmatterDescription = (contents) => {
+    if (!contents.startsWith("---\n") && !contents.startsWith("---\r\n"))
+        return "";
+    const end = contents.indexOf("\n---", 3);
+    if (end === -1)
+        return "";
+    for (const line of contents.slice(0, end).split("\n")) {
+        const match = /^description:\s*(.*)$/.exec(line);
+        if (match === null)
+            continue;
+        const raw = (match[1] ?? "").trim();
+        if (raw === "" || raw === "|" || raw === ">" || raw === "|-" || raw === ">-")
+            return "";
+        const quoted = /^(['"])(.*)\1$/.exec(raw);
+        return quoted?.[2] ?? raw;
+    }
+    return "";
+};
+const walkFiles = (root) => {
+    const found = [];
+    const visit = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (IGNORED_DIRS.has(entry.name))
+                continue;
+            const absolute = path.join(dir, entry.name);
+            // stat (not the dirent) so symlinked files and directories both count.
+            let stat;
+            try {
+                stat = fs.statSync(absolute);
+            }
+            catch {
+                continue; // dangling symlink
+            }
+            if (stat.isDirectory())
+                visit(absolute);
+            else if (stat.isFile())
+                found.push(absolute);
+        }
+    };
+    visit(root);
+    return found.toSorted();
+};
+/**
+ * Scan a skill library directory: every immediate subdirectory carrying a
+ * `SKILL.md` becomes one bundle. Oversized and binary files are skipped with
+ * a note; a directory without a SKILL.md is noted and left out entirely.
+ */
+export const scanSkillLibrary = (root) => {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return { error: `${root} is not a readable directory` };
+    }
+    const skills = [];
+    const notes = [];
+    for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.name.startsWith("."))
+            continue;
+        const skillDir = path.join(root, entry.name);
+        let stat;
+        try {
+            stat = fs.statSync(skillDir);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        if (!fs.existsSync(path.join(skillDir, "SKILL.md"))) {
+            notes.push({ skill: entry.name, message: "no SKILL.md — skipped" });
+            continue;
+        }
+        const files = [];
+        let bytes = 0;
+        for (const absolute of walkFiles(skillDir)) {
+            const relative = path.relative(skillDir, absolute).split(path.sep).join("/");
+            const buffer = fs.readFileSync(absolute);
+            if (buffer.byteLength > MAX_SKILL_FILE_BYTES) {
+                notes.push({ skill: entry.name, message: `${relative} is over 512KB — skipped` });
+                continue;
+            }
+            if (!isTextBuffer(buffer)) {
+                notes.push({ skill: entry.name, message: `${relative} is binary — skipped` });
+                continue;
+            }
+            files.push({ path: relative, contents: buffer.toString("utf8") });
+            bytes += buffer.byteLength;
+        }
+        if (files.length > MAX_SKILL_FILES) {
+            notes.push({
+                skill: entry.name,
+                message: `${files.length} files is over the ${MAX_SKILL_FILES}-file cap — skipped`,
+            });
+            continue;
+        }
+        const entryFile = files.find((file) => file.path === "SKILL.md");
+        if (entryFile === undefined) {
+            notes.push({ skill: entry.name, message: "SKILL.md was unreadable — skipped" });
+            continue;
+        }
+        skills.push({
+            name: entry.name.toLowerCase(),
+            description: readFrontmatterDescription(entryFile.contents),
+            files,
+            bytes,
+        });
+    }
+    return { skills, notes };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/mend",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "The mend CLI: adopt a repository into Mend's store, launch your coding agent in a recorded session worktree, detach and reattach from any terminal",
   "keywords": [
     "claude-code",