moshcode 0.69.0 → 0.70.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.69.0",
+  "version": "0.70.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "repository": {

package/src/integrations.mjs

@@ -253,7 +253,7 @@ export async function mcpCommand(tokens, { run, installedSet } = {}) {
 }
 
 /** Run `/skill …`. `tokens` are the words after `skill`. `run`/`installedSet` are injectable for tests. */
-export async function skillCommand(tokens, { run, installedSet } = {}) {
+export async function skillCommand(tokens, { run, installedSet, settle } = {}) {
   const verb = tokens[0];
   if (!verb || verb === "list") { printSkillTargets(tokens.slice(1).includes("--json")); return 0; }
   if (verb !== "install") {
@@ -287,7 +287,10 @@ export async function skillCommand(tokens, { run, installedSet } = {}) {
 
   const spec = { source, name: skillName(source, name) };
   console.log(info(`installing skill ${bone(spec.name)} → ${ash(source)} across skills engines…`));
-  const results = await runSkillInstall(planSkillInstall(spec, { installedSet }), run ? { run } : {});
+  const results = await runSkillInstall(planSkillInstall(spec, { installedSet }), {
+    ...(run ? { run } : {}),
+    ...(settle ? { settle } : {}),
+  });
   summarize(results);
   return anyFailed(results) ? 1 : 0;
 }

package/src/skills.mjs

@@ -1,6 +1,7 @@
 // Install Agent Skills across every engine that has a skills primitive, from one
 // source (a git URL or local path). Gemini installs natively; Claude clones the
 // source into its personal skills dir. See prd/0003.
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { ENGINES, isInstalled, ranOk, runCmd } from "./engines.mjs";
@@ -38,6 +39,61 @@ export function skillName(source, override) {
   return named(sanitize(path.basename(path.resolve(raw)))) || "skill";
 }
 
+/**
+ * What a freshly cloned skill source actually contains.
+ *
+ * A repository is not always one skill. `SKILL.md` at the root is the common
+ * shape and the one this module assumed. But a repository can equally be a
+ * *collection* — subdirectories that each hold a `SKILL.md` — and every engine
+ * that discovers skills by scanning looks exactly one level deep. Cloning a
+ * collection whole therefore lands every skill one level too deep, where
+ * nothing will ever find them, while `git clone` still exits 0 and the install
+ * reports success. Detecting the shape is what makes that failure impossible.
+ */
+export function skillCollection(dir) {
+  if (!fs.existsSync(dir)) return { kind: "empty", names: [] };
+  if (fs.existsSync(path.join(dir, "SKILL.md"))) return { kind: "single", names: [] };
+  const names = fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !d.name.startsWith("."))
+    .filter((d) => fs.existsSync(path.join(dir, d.name, "SKILL.md")))
+    .map((d) => d.name)
+    .sort();
+  return names.length ? { kind: "collection", names } : { kind: "empty", names: [] };
+}
+
+/**
+ * Settle a fresh clone into the shape the engine scans, and report what it was.
+ *
+ * `single` is left exactly as cloned. `collection` has each skill moved up
+ * beside its siblings and the wrapper removed — the wrapper holds the
+ * repository's own README, tooling and CI, none of which is a skill. `empty`
+ * removes the clone rather than leaving a directory that can never resolve.
+ *
+ * A skill whose name is already taken is left alone and reported in `kept`:
+ * this runs inside the user's real skills directory, so a name collision must
+ * never silently replace a skill they already had.
+ */
+export function settleSkillClone(dir) {
+  const { kind, names } = skillCollection(dir);
+  if (kind === "single") return { kind, installed: [path.basename(dir)], kept: [] };
+  if (kind === "empty") {
+    fs.rmSync(dir, { recursive: true, force: true });
+    return { kind, installed: [], kept: [] };
+  }
+  const parent = path.dirname(dir);
+  const installed = [];
+  const kept = [];
+  for (const name of names) {
+    const dest = path.join(parent, name);
+    if (fs.existsSync(dest)) { kept.push(name); continue; }
+    fs.renameSync(path.join(dir, name), dest);
+    installed.push(name);
+  }
+  fs.rmSync(dir, { recursive: true, force: true });
+  return { kind, installed, kept };
+}
+
 /**
  * The install action for one engine: a spawnable { cmd, args } or a { skip }
  * reason. `spec: { source, name }`.
@@ -47,13 +103,19 @@ export function skillInstallAction(key, spec) {
   switch (key) {
     case "gemini":
       return { cmd: "gemini", args: ["skills", "install", source, "--scope", "user"] };
-    case "claude":
+    case "claude": {
       // Claude has no `skill install`; clone the source into its skills dir.
-      return { cmd: "git", args: ["clone", "--depth", "1", source, path.join(claudeSkillsDir(), name)] };
-    case "kimi":
+      // `settle` is the cloned path: a scanning engine needs the clone resolved
+      // into one-level-deep skills afterwards (see settleSkillClone).
+      const dir = path.join(claudeSkillsDir(), name);
+      return { cmd: "git", args: ["clone", "--depth", "1", source, dir], settle: dir };
+    }
+    case "kimi": {
       // Kimi Code discovers skills by scanning directories, with no install
       // command of its own — so clone into the one it scans, as Claude does.
-      return { cmd: "git", args: ["clone", "--depth", "1", source, path.join(kimiSkillsDir(), name)] };
+      const dir = path.join(kimiSkillsDir(), name);
+      return { cmd: "git", args: ["clone", "--depth", "1", source, dir], settle: dir };
+    }
     default:
       return { skip: "no skills primitive" };
   }
@@ -81,13 +143,23 @@ export function planSkillInstall(spec, { installedSet } = {}) {
  * [{ key, status: "installed"|"skipped"|"failed"|"not-installed", reason? }].
  * `run` is injectable for tests.
  */
-export async function runSkillInstall(plan, { run = runCmd } = {}) {
+export async function runSkillInstall(plan, { run = runCmd, settle = settleSkillClone } = {}) {
   const results = [];
   for (const item of plan) {
     if (item.skip) { results.push({ key: item.key, status: "skipped", reason: item.skip }); continue; }
     if (!item.installed) { results.push({ key: item.key, status: "not-installed" }); continue; }
     const r = await run(item.cmd, item.args);
-    results.push({ key: item.key, status: ranOk(r) ? "installed" : "failed", code: r.code, signal: r.signal ?? null });
+    const base = { key: item.key, code: r.code, signal: r.signal ?? null };
+    if (!ranOk(r)) { results.push({ ...base, status: "failed" }); continue; }
+    if (!item.settle) { results.push({ ...base, status: "installed" }); continue; }
+
+    // The clone succeeded, which is not the same as a skill being installed.
+    const { kind, installed, kept } = settle(item.settle);
+    if (kind === "empty") {
+      results.push({ ...base, status: "failed", reason: "no SKILL.md at the root or in any subdirectory" });
+      continue;
+    }
+    results.push({ ...base, status: "installed", kind, skills: installed, ...(kept.length ? { kept } : {}) });
   }
   return results;
 }