@michengai/dsh-skills-manager 1.1.19 → 1.1.21

package/lib/core.js

@@ -118,7 +118,7 @@ function userRoots() {
       key: "agents",
       path: join(resolveAgentsHome(), "skills"),
       label: "\u516C\u5171 Agent",
-      mutable: false,
+      mutable: true,
       toggleable: true,
       native: true,
       rank: 450
@@ -611,11 +611,11 @@ function rootDefinition(root) {
 function rootByKey(key) {
   return userRoots().find((item) => item.key === key) || null;
 }
-function writableRootDefinition(root, allowRepositoryRoot = false) {
+function writableRootDefinition(root) {
   const definition = rootDefinition(root);
-  if (allowRepositoryRoot && definition?.key === "agents") {
+  if (definition?.key === "agents") {
     const canonical = rootByKey("agents");
-    return canonical && resolve(definition.path) === resolve(canonical.path) ? { ...canonical, mutable: true } : null;
+    return canonical && resolve(definition.path) === resolve(canonical.path) ? canonical : null;
   }
   if (!definition || definition.mutable !== true) return null;
   if (definition.key === "dsh")
@@ -624,16 +624,18 @@ function writableRootDefinition(root, allowRepositoryRoot = false) {
     return null;
   return definition;
 }
-async function checkedWritableRootDefinition(root, allowRepositoryRoot = false) {
-  const definition = writableRootDefinition(root, allowRepositoryRoot);
-  if (definition && definition.scope !== "project" && allowRepositoryRoot) {
-    for (let path = resolve(definition.path); ; path = dirname(path)) {
-      const st = await lstatOrNull(path);
-      if (st && (!st.isDirectory() || st.isSymbolicLink()))
-        return { ok: false, error: `\u6280\u80FD\u76EE\u5F55\u4E0D\u5B89\u5168\uFF0C\u62D2\u7EDD\u5199\u5165: ${path}`, code: "error.root.unsafe", params: { path } };
-      if (dirname(path) === path) break;
-    }
+async function checkedUserRootAncestors(definition) {
+  for (let path = resolve(definition.path); ; path = dirname(path)) {
+    const st = await lstatOrNull(path);
+    if (st && (!st.isDirectory() || st.isSymbolicLink()))
+      return { ok: false, error: `\u6280\u80FD\u76EE\u5F55\u4E0D\u5B89\u5168\uFF0C\u62D2\u7EDD\u5199\u5165: ${path}`, code: "error.root.unsafe", params: { path } };
+    if (dirname(path) === path) break;
   }
+  return definition;
+}
+async function checkedWritableRootDefinition(root) {
+  const definition = writableRootDefinition(root);
+  if (definition?.key === "agents") return checkedUserRootAncestors(definition);
   if (!definition || definition.scope !== "project") return definition;
   if (await overlapsUserSkillRoot(definition.path)) {
     return {
@@ -656,12 +658,17 @@ async function checkedWritableRootDefinition(root, allowRepositoryRoot = false)
   }
   return definition;
 }
+async function checkedRepositoryRootDefinition(root) {
+  const definition = await checkedWritableRootDefinition(root);
+  if (!definition || definition.ok === false || definition.scope === "project" || definition.key === "agents") return definition;
+  return checkedUserRootAncestors(definition);
+}
 async function repositoryDestinations() {
   const result = [];
   for (const root of userRoots().filter((item) => item.key === "dsh" || item.key === "agents")) {
     let error;
     try {
-      const checked = await checkedWritableRootDefinition(root, true);
+      const checked = await checkedRepositoryRootDefinition(root);
       if (!checked || checked.ok === false) error = checked || { code: "error.root.unsafe", error: "\u6280\u80FD\u5B89\u88C5\u4F4D\u7F6E\u4E0D\u53EF\u7528" };
     } catch (caught) {
       const exception = caught;
@@ -768,21 +775,22 @@ function parseSkillDoc(text) {
         const m = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(lines[i]);
         if (m) {
           fields.push({ key: m[1], raw: m[2] });
-          const block = /^([>|])[-+]?\s*$/.exec(m[2]);
+          const block = /^([>|])(?:([1-9])[-+]?|[-+]([1-9])?)?\s*$/.exec(m[2]);
           if (block) {
             const content = [];
             while (i + 1 < end && (/^\s/.test(lines[i + 1]) || lines[i + 1] === "")) {
               i++;
               content.push(lines[i]);
             }
-            const indentation = content.filter((line) => line.trim() !== "").reduce(
+            const explicitIndentation = block[2] || block[3];
+            const indentation = explicitIndentation ? Number(explicitIndentation) : content.filter((line) => line.trim() !== "").reduce(
               (min, line) => Math.min(min, (/^\s*/.exec(line) || [""])[0].length),
               Infinity
             );
             const normalized = content.map(
               (line) => Number.isFinite(indentation) ? line.slice(Math.min(indentation, line.length)) : line
             );
-            map[m[1]] = block[1] === ">" ? normalized.join(" ").replace(/\s+/g, " ").trim() : normalized.join("\n").trim();
+            map[m[1]] = block[1] === ">" ? normalized.join(" ").replace(/\s+/g, " ").trim() : explicitIndentation ? normalized.join("\n").replace(/^\n+|\n+$/g, "") : normalized.join("\n").trim();
           } else {
             map[m[1]] = decodeYamlScalar(m[2]);
           }
@@ -894,7 +902,7 @@ function parseBoolValue(raw) {
 }
 async function resolveEntry(root, name) {
   const definition = rootDefinition(root);
-  if (definition && !definition.mutable) {
+  if (definition && (!definition.mutable || definition.key === "agents")) {
     if (!validDiscoveryName(name)) return null;
     return (await discoverReadonlyEntries(definition.path)).entries.find(
       (entry) => entry.name === name
@@ -960,7 +968,7 @@ function entryOf(name, kind, docPath, doc) {
     });
   if (doc.hasFrontmatter && !declaredName)
     diagnostics.push({ level: "error", code: "diagnostic.name.missing" });
-  else if (declaredName && !KEBAB_RE.test(declaredName))
+  else if (declaredName && !KEBAB_RE.test(toKebab(declaredName)))
     diagnostics.push({
       level: "error",
       code: "diagnostic.name.invalid",
@@ -984,13 +992,13 @@ function entryOf(name, kind, docPath, doc) {
     invocationPolicyValid,
     hasFrontmatter: doc.hasFrontmatter,
     // 调用策略值异常可以由 manager 本地策略覆盖；结构本身合法即可加载。
-    loadable: doc.hasFrontmatter && KEBAB_RE.test(declaredName) && description !== "",
+    loadable: doc.hasFrontmatter && description !== "" && KEBAB_RE.test(KEBAB_RE.test(declaredName) ? declaredName : toKebab(declaredName)),
     diagnostics
   };
 }
 async function scanEntries(root, options = {}) {
   const definition = rootDefinition(root);
-  if (definition && !definition.mutable) {
+  if (definition && (!definition.mutable || definition.key === "agents")) {
     const discovered = await discoverReadonlyEntries(definition.path);
     if (options.metadataOnly) return discovered;
     const entries2 = [];
@@ -1113,7 +1121,7 @@ function defaultManagerState() {
     disabledSkills[root.key] = [];
     enabledSkills[root.key] = [];
   }
-  return { version: 1, sources, disabledSkills, enabledSkills, categories: /* @__PURE__ */ Object.create(null), categoryMembers: /* @__PURE__ */ Object.create(null) };
+  return { version: 1, sources, disabledSkills, enabledSkills, categories: /* @__PURE__ */ Object.create(null), categoryMembers: /* @__PURE__ */ Object.create(null), categoryOrder: /* @__PURE__ */ Object.create(null) };
 }
 function validStateSkillName(name) {
   return validDiscoveryName(name);
@@ -1214,6 +1222,7 @@ function normalizeManagerState(value) {
   }
   normalized.categories = normalizeCategories(value.categories);
   normalized.categoryMembers = normalizeCategoryMembers(value.categoryMembers, normalized.categories);
+  normalized.categoryOrder = normalizeCategoryOrder(value.categoryOrder, normalized.categories);
   return normalized;
 }
 const CATEGORY_NAME_MAX = 24;
@@ -1252,6 +1261,20 @@ function normalizeCategoryMembers(value, categories) {
   }
   return members;
 }
+function normalizeCategoryOrder(value, categories) {
+  const order = /* @__PURE__ */ Object.create(null);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return order;
+  for (const [key, groups] of Object.entries(value)) {
+    if (!categoryRootKey(key) || !groups || typeof groups !== "object" || Array.isArray(groups)) continue;
+    const validIds = /* @__PURE__ */ new Set(["", ...(categories[key] || []).map((item) => item.id)]);
+    order[key] = /* @__PURE__ */ Object.create(null);
+    for (const [id, names] of Object.entries(groups)) {
+      if (!validIds.has(id) || !Array.isArray(names)) continue;
+      order[key][id] = [...new Set(names.filter(validStateSkillName))];
+    }
+  }
+  return order;
+}
 async function readManagerState() {
   try {
     const raw = await fs.readFile(managerStatePath(), "utf8");
@@ -1480,6 +1503,7 @@ async function writableCategoryState(key, options = {}) {
   if (current.writable === false) return invalidManagerStateWrite();
   if (!current.state.categories[root.key]) current.state.categories[root.key] = [];
   if (!current.state.categoryMembers[root.key]) current.state.categoryMembers[root.key] = /* @__PURE__ */ Object.create(null);
+  if (!current.state.categoryOrder[root.key]) current.state.categoryOrder[root.key] = /* @__PURE__ */ Object.create(null);
   return { rootKey: root.key, root, state: current.state };
 }
 async function createCategory(key, name, log, options = {}) {
@@ -1492,6 +1516,7 @@ async function createCategory(key, name, log, options = {}) {
     return categoryError("error.category.duplicate", `\u5DF2\u6709\u540C\u540D\u5206\u7C7B: ${label}`, { name: label });
   const category = { id: randomBytes(8).toString("hex"), name: label };
   ready.state.categories[ready.rootKey].push(category);
+  ready.state.categoryOrder[ready.rootKey][category.id] = [];
   await writeManagerState(ready.state);
   if (log) log("category-create", `\u5728 ${ready.rootKey} \u6DFB\u52A0\u5206\u7C7B ${label}`);
   return { root: ready.rootKey, category };
@@ -1518,6 +1543,7 @@ async function deleteCategory(key, id, log, options = {}) {
   const list = ready.state.categories[ready.rootKey];
   if (!list.some((item) => item.id === id)) return categoryError("error.category.notFound", "\u5206\u7C7B\u4E0D\u5B58\u5728", { id });
   ready.state.categories[ready.rootKey] = list.filter((item) => item.id !== id);
+  delete ready.state.categoryOrder[ready.rootKey][id];
   for (const [skillName, categoryId] of Object.entries(ready.state.categoryMembers[ready.rootKey])) {
     if (categoryId === id) delete ready.state.categoryMembers[ready.rootKey][skillName];
   }
@@ -1536,12 +1562,67 @@ async function assignSkillCategory(key, skillName, categoryId, log, options = {}
       return categoryError("error.skill.notFound", `\u6280\u80FD\u4E0D\u5B58\u5728: ${skillName}`, { name: skillName });
     if (!ready.state.categories[ready.rootKey].some((item) => item.id === categoryId))
       return categoryError("error.category.notFound", "\u5206\u7C7B\u4E0D\u5B58\u5728", { id: categoryId });
+    const previousId = ready.state.categoryMembers[ready.rootKey][skillName] || "";
+    if (previousId !== categoryId) {
+      ready.state.categoryOrder[ready.rootKey][previousId] = (ready.state.categoryOrder[ready.rootKey][previousId] || []).filter((name) => name !== skillName);
+      const targetOrder = ready.state.categoryOrder[ready.rootKey][categoryId] || [];
+      if (!targetOrder.includes(skillName)) targetOrder.push(skillName);
+      ready.state.categoryOrder[ready.rootKey][categoryId] = targetOrder;
+    }
     ready.state.categoryMembers[ready.rootKey][skillName] = categoryId;
-  } else delete ready.state.categoryMembers[ready.rootKey][skillName];
+  } else {
+    const previousId = ready.state.categoryMembers[ready.rootKey][skillName] || "";
+    if (previousId) {
+      ready.state.categoryOrder[ready.rootKey][previousId] = (ready.state.categoryOrder[ready.rootKey][previousId] || []).filter((name) => name !== skillName);
+      const looseOrder = ready.state.categoryOrder[ready.rootKey][""] || [];
+      if (!looseOrder.includes(skillName)) looseOrder.push(skillName);
+      ready.state.categoryOrder[ready.rootKey][""] = looseOrder;
+    }
+    delete ready.state.categoryMembers[ready.rootKey][skillName];
+  }
   await writeManagerState(ready.state);
   if (log) log("category-assign", `${ready.rootKey}/${skillName} \u5F52\u5165 ${categoryId || "\u672A\u5206\u7C7B"}`);
   return { root: ready.rootKey, name: skillName, categoryId: categoryId || null };
 }
+async function moveSkillInCategory(key, skillName, categoryId, targetName, position = "before", log, options = {}) {
+  const ready = await writableCategoryState(key, options);
+  if ("ok" in ready) return ready;
+  if (!validStateSkillName(skillName))
+    return categoryError("error.skill.notFound", `\u6280\u80FD\u4E0D\u5B58\u5728: ${skillName}`, { name: skillName });
+  if (categoryId && !ready.state.categories[ready.rootKey].some((item) => item.id === categoryId))
+    return categoryError("error.category.notFound", "\u5206\u7C7B\u4E0D\u5B58\u5728", { id: categoryId });
+  if (position !== "before" && position !== "after")
+    return categoryError("error.category.position", "\u6280\u80FD\u6392\u5E8F\u4F4D\u7F6E\u65E0\u6548");
+  const entries = (await scanEntries(ready.root)).entries.map((entry) => entry.name);
+  if (!entries.includes(skillName))
+    return categoryError("error.skill.notFound", `\u6280\u80FD\u4E0D\u5B58\u5728: ${skillName}`, { name: skillName });
+  if (targetName && (!validStateSkillName(targetName) || !entries.includes(targetName)))
+    return categoryError("error.skill.notFound", `\u6392\u5E8F\u76EE\u6807\u4E0D\u5B58\u5728: ${targetName}`, { name: targetName });
+  const members = ready.state.categoryMembers[ready.rootKey];
+  const orders = ready.state.categoryOrder[ready.rootKey];
+  const previousId = members[skillName] || "";
+  const orderedNames = (id) => {
+    const available = entries.filter((name) => (members[name] || "") === id).sort((a, b) => a.localeCompare(b));
+    const availableSet = new Set(available);
+    const saved = (orders[id] || []).filter((name) => availableSet.has(name));
+    return [...saved, ...available.filter((name) => !saved.includes(name))];
+  };
+  if (targetName && (members[targetName] || "") !== categoryId)
+    return categoryError("error.category.target", "\u6392\u5E8F\u76EE\u6807\u4E0D\u5C5E\u4E8E\u76EE\u6807\u5206\u7C7B", { name: targetName, category: categoryId });
+  const sourceOrder = orderedNames(previousId).filter((name) => name !== skillName);
+  const targetOrder = previousId === categoryId ? sourceOrder : orderedNames(categoryId).filter((name) => name !== skillName);
+  let index = targetName ? targetOrder.indexOf(targetName) : -1;
+  if (index < 0) index = targetOrder.length;
+  else if (position === "after") index += 1;
+  targetOrder.splice(index, 0, skillName);
+  if (previousId !== categoryId) orders[previousId] = sourceOrder;
+  orders[categoryId] = targetOrder;
+  if (categoryId) members[skillName] = categoryId;
+  else delete members[skillName];
+  await writeManagerState(ready.state);
+  if (log) log("category-order", `${ready.rootKey}/${skillName} \u79FB\u81F3 ${categoryId || "\u672A\u5206\u7C7B"} ${position} ${targetName || "\u672B\u5C3E"}`);
+  return { root: ready.rootKey, name: skillName, categoryId: categoryId || null, order: targetOrder };
+}
 async function setCategoryEnabled(key, categoryId, enabled, log, options = {}) {
   const ready = await writableCategoryState(key, options);
   if ("ok" in ready) return ready;
@@ -1647,7 +1728,7 @@ function trashRootMetadata(definition) {
 async function restoreRootDefinition(metadata, options = {}) {
   if (!metadata.root) return rootByKey("dsh");
   if (metadata.root.scope === "user" && rootByKey(metadata.root.key))
-    return checkedWritableRootDefinition(rootByKey(metadata.root.key), metadata.root.key !== "dsh");
+    return checkedWritableRootDefinition(rootByKey(metadata.root.key));
   if (metadata.root.scope !== "project" || metadata.root.kind !== "project-dsh" || typeof metadata.root.key !== "string" || typeof metadata.root.projectRoot !== "string" || !isAbsolute(metadata.root.projectRoot))
     return {
       ok: false,
@@ -1670,7 +1751,7 @@ async function restoreRootDefinition(metadata, options = {}) {
   return checkedWritableRootDefinition(root);
 }
 async function deleteSkill(root, name, log, options = {}) {
-  const definition = await checkedWritableRootDefinition(root, options.allowRepositoryRoot === true);
+  const definition = await checkedWritableRootDefinition(root);
   if (definition && definition.ok === false) return definition;
   if (!definition) return readonlyError("delete");
   const resolved = await resolveEntry(definition, name);
@@ -1683,7 +1764,13 @@ async function deleteSkill(root, name, log, options = {}) {
     };
   const targets = (await safeExistingEntryPaths(definition.path, name)).filter((target) => !options.repositoryEntryOnly || target.fileName === name);
   if (!targets.length) return { ok: false, error: `\u6280\u80FD\u4E0D\u5B58\u5728: ${name}`, code: "error.skill.notFound", params: { name } };
-  const id = options.repositoryTrash?.id || `${Date.now()}-${randomUUID()}`;
+  if (definition.key === "agents") {
+    for (const target of targets) {
+      if ((await lstatOrNull(target.path))?.isSymbolicLink())
+        return { ok: false, error: `\u6280\u80FD\u76EE\u5F55\u4E0D\u5B89\u5168\uFF0C\u62D2\u7EDD\u5199\u5165: ${target.path}`, code: "error.root.unsafe", params: { path: target.path } };
+    }
+  }
+  const id = options.repositoryTrash?.id || options.catalogTrash?.id || `${Date.now()}-${randomUUID()}`;
   if (!/^\d+-[a-f0-9-]{36}$/.test(id)) throw codedError("\u56DE\u6536\u7AD9\u6761\u76EE\u7F16\u53F7\u975E\u6CD5", "error.trash.invalid", { id });
   const trashRoot = trashRootPath();
   const stage = join(trashRoot, `.stage-${randomUUID()}`);
@@ -1712,7 +1799,8 @@ async function deleteSkill(root, name, log, options = {}) {
       deletedAt: (/* @__PURE__ */ new Date()).toISOString(),
       entries: moved.map((item) => item.fileName),
       root: trashRootMetadata(definition),
-      ...options.repositoryTrash ? { repository: options.repositoryTrash.repository } : {}
+      ...options.repositoryTrash ? { repository: options.repositoryTrash.repository } : {},
+      ...options.catalogTrash ? { catalog: options.catalogTrash.ids } : {}
     };
     await fs.writeFile(
       join(stage, "metadata.json"),
@@ -1840,8 +1928,15 @@ async function forgetCategoryMember(metadata) {
   const current = await readManagerState();
   if (current.writable === false) return;
   const members = current.state.categoryMembers[key];
-  if (!members || !members[metadata.name]) return;
-  delete members[metadata.name];
+  const orders = current.state.categoryOrder[key];
+  const hasMember = !!(members && members[metadata.name]);
+  const hasOrder = !!(orders && Object.values(orders).some((names) => names.includes(metadata.name)));
+  if (!hasMember && !hasOrder) return;
+  if (members) delete members[metadata.name];
+  if (orders) {
+    for (const id of Object.keys(orders))
+      orders[id] = orders[id].filter((name) => name !== metadata.name);
+  }
   await writeManagerState(current.state);
 }
 async function permanentlyDeleteTrash(id, log) {
@@ -2092,7 +2187,7 @@ async function replaceWithCopy(source, dest, isDir, existing = []) {
 }
 async function importSkill(source, log, options = {}) {
   const requestedRoot = Object.prototype.hasOwnProperty.call(options, "root") ? options.root : rootByKey("dsh");
-  const definition = await checkedWritableRootDefinition(requestedRoot, options.allowRepositoryRoot === true);
+  const definition = await checkedWritableRootDefinition(requestedRoot);
   if (definition && definition.ok === false) return definition;
   if (!definition) return readonlyError("create");
   const targetRoot = definition.path;
@@ -2214,6 +2309,7 @@ async function importSkill(source, log, options = {}) {
     if (pending.length === 0 && conflicts.length === 0) return failureResult();
     return { kind: analysis.kind, pending, conflicts, failed };
   }
+  if (!dryRun && options.beforeImport) await options.beforeImport(pending, conflicts, failed);
   if (pending.length > 0 || conflict === "overwrite" && conflicts.length > 0) {
     await fs.mkdir(targetRoot, { recursive: true });
   }
@@ -2449,7 +2545,7 @@ function yamlString(value) {
 }
 async function createSkill(input, log, options = {}) {
   const requestedRoot = Object.prototype.hasOwnProperty.call(options, "root") ? options.root : rootByKey("dsh");
-  const definition = await checkedWritableRootDefinition(requestedRoot, options.allowRepositoryRoot === true);
+  const definition = await checkedWritableRootDefinition(requestedRoot);
   if (definition && definition.ok === false) return definition;
   if (!definition) return readonlyError("create");
   const root = definition.path;
@@ -2575,12 +2671,12 @@ async function listProviderCandidates(options = {}) {
     const hasExplicitDisable = group.some((item) => item.policy.override === false);
     if (!hasNativeCopy && !hasExplicitDisable && !policy.sourceEnabled) continue;
     const project = root.scope === "project";
-    const policyOnly = root.mutable;
+    const policyOnly = root.mutable && root.key !== "agents";
     const overlayRank = group.length > 1 ? Math.min(...group.map((item) => Math.min(item.root.rank, item.entry.providerRank ?? item.root.rank))) - 1 : void 0;
     const needsOverlay = !policyOnly || group.length > 1 || policy.override !== void 0 || !entry.invocationPolicyValid || policyResult.writable === false;
     if (!needsOverlay) continue;
     candidates.push({
-      name: entry.declaredName,
+      name: canonicalSkillName({ root, entry, policy }),
       description: entry.description,
       invocation: {
         modelInvocable: policy.modelInvocable,
@@ -2636,8 +2732,9 @@ async function getProviderSkill(candidate, options = {}) {
       await fs.readFile(entry.realDocPath || entry.docPath, "utf8")
     );
     const summary = entryOf(locator.entryName, entry.kind, entry.docPath, doc);
-    if (!summary.loadable || summary.declaredName !== candidate.name)
-      return void 0;
+    if (!summary.loadable) return void 0;
+    const invocationName = KEBAB_RE.test(summary.declaredName) ? summary.declaredName : toKebab(summary.declaredName);
+    if (invocationName !== candidate.name && summary.declaredName !== candidate.name) return void 0;
     return {
       name: candidate.name,
       description: candidate.description,
@@ -2654,7 +2751,10 @@ async function getProviderSkill(candidate, options = {}) {
   }
 }
 function canonicalSkillName(item) {
-  return item.entry.declaredName || item.entry.name;
+  const declared = item.entry.declaredName || "";
+  if (KEBAB_RE.test(declared)) return declared;
+  const kebab = toKebab(declared);
+  return kebab || declared || item.entry.name;
 }
 function groupLoadableSkillsByName(items) {
   const groups = /* @__PURE__ */ new Map();
@@ -2834,7 +2934,8 @@ async function state(options = {}) {
       truncated: truncated === true,
       enabled: policyResult.writable !== false && (root.kind === "project-dsh" || policyResult.state.sources[root.key] !== false),
       skills,
-      categories: policyResult.state.categories[root.key] || []
+      categories: policyResult.state.categories[root.key] || [],
+      categoryOrder: policyResult.state.categoryOrder[root.key] || {}
     });
   }
   const userItems = all.filter((item) => item.root.scope !== "project");
@@ -2876,6 +2977,7 @@ export {
   KEBAB_RE,
   assignSkillCategory,
   browseDirectories,
+  checkedRepositoryRootDefinition,
   createCategory,
   createSkill,
   createWorkspaceIndex,
@@ -2892,6 +2994,7 @@ export {
   logPath,
   managerHomePath,
   managerStatePath,
+  moveSkillInCategory,
   parseBoolValue,
   parseSkillDoc,
   permanentlyDeleteTrash,

package/lib/index.js

@@ -7,9 +7,8 @@ import {
   renameCategory,
   deleteCategory,
   assignSkillCategory,
+  moveSkillInCategory,
   setCategoryEnabled,
-  deleteSkill,
-  permanentlyDeleteTrash,
   importSkill,
   importUploadedSkill,
   browseDirectories,
@@ -27,6 +26,9 @@ import {
 import { registerPluginUpdater } from "./plugin-updater.js";
 import { createRepositoryManager } from "./repositories.js";
 import { installationSourceKey } from "./repository-updates.js";
+import { listClawHub, searchClawHub } from "./clawhub-catalog.js";
+import { searchSkillsSh } from "./skills-sh-catalog.js";
+import { loadCatalogPackage, readCatalogSkill } from "./catalog-skill.js";
 const name = "skills-manager";
 const inject = ["webServer", "skills", "tools", "sessions"];
 const CLIENT_MARKER_HEADER = "x-dsh-skills-manager";
@@ -362,7 +364,6 @@ function apply(ctx) {
         return { projectCwds: target.root.workspaceCwds ?? [] };
       };
       const scopedOptions = (scope) => scope ?? projectOptions();
-      const userWriteOptions = (body, target) => ({ allowRepositoryRoot: !target && body.root === "agents" });
       const requestRoot = async (key, cwds) => cwds ? (await projectRoots(cwds)).find((root) => root.key === key) : rootByKey[key] || (await projectRoots(projectOptions().projectCwds)).find((root) => root.key === key);
       const withScope = async (body, action) => {
         const scope = await workspaceScope(body);
@@ -396,7 +397,25 @@ function apply(ctx) {
           return run(res, async () => ({ items: await listWorkspaces(registeredWorkspacePaths(ctx) ?? []) }), void 0, req.method === "HEAD");
         }
         if ((req.method === "GET" || req.method === "HEAD") && path === "/api/dsh-skills-manager/repositories") {
-          return run(res, () => repositories.list(), void 0, req.method === "HEAD");
+          return run(res, () => enqueueMutation(() => repositories.list()), void 0, req.method === "HEAD");
+        }
+        if (req.method === "GET" && (path === "/api/dsh-skills-manager/clawhub/list" || path === "/api/dsh-skills-manager/clawhub/search")) {
+          const searching = path.endsWith("/search");
+          const allowed = searching ? ["q", "limit"] : ["limit", "cursor", "sort"];
+          if ([...u.searchParams.keys()].some((key) => !allowed.includes(key) || u.searchParams.getAll(key).length !== 1) || searching && !u.searchParams.has("q")) {
+            json(res, 400, { ok: false, code: "error.catalog.query", error: "\u76EE\u5F55\u67E5\u8BE2\u53C2\u6570\u65E0\u6548" });
+            return;
+          }
+          const parameter = (key) => u.searchParams.get(key) ?? void 0;
+          return run(res, () => searching ? searchClawHub(parameter("q"), { limit: parameter("limit") }) : listClawHub({ limit: parameter("limit"), sort: parameter("sort"), cursor: parameter("cursor") }));
+        }
+        if (req.method === "GET" && path === "/api/dsh-skills-manager/skills-sh/search") {
+          const queries = u.searchParams.getAll("q");
+          if (queries.length !== 1) {
+            json(res, 400, { ok: false, code: "error.catalog.query", error: "\u641C\u7D22\u8BCD\u4E0D\u80FD\u4E3A\u7A7A\u4E14\u4E0D\u80FD\u8D85\u8FC7 100 \u4E2A\u5B57\u7B26" });
+            return;
+          }
+          return run(res, () => searchSkillsSh(queries[0]));
         }
         if (req.method === "HEAD") {
           if (path === "/api/dsh-skills-manager/state") return run(res, stateWithSources, void 0, true);
@@ -421,6 +440,18 @@ function apply(ctx) {
           return run(res, () => browseDirectories(body.path));
         }
         if (path === "/api/dsh-skills-manager/repositories/refresh") return run(res, () => repositories.refresh(body));
+        if (path === "/api/dsh-skills-manager/catalog/detail") return run(res, () => readCatalogSkill(body));
+        if (path === "/api/dsh-skills-manager/catalog/install") {
+          return run(res, async () => {
+            if (body.root !== void 0 && body.root !== "dsh" && body.root !== "agents") throw Object.assign(new Error("\u6280\u80FD\u5B89\u88C5\u4F4D\u7F6E\u65E0\u6548"), { statusCode: 400, code: "error.repo.invalid" });
+            if (body.workspace !== void 0 && body.root !== void 0 && body.root !== "dsh") throw Object.assign(new Error("\u5DE5\u4F5C\u533A\u53EA\u80FD\u5B89\u88C5\u5230\u9879\u76EE DSH skills"), { statusCode: 400, code: "error.repo.invalid" });
+            const target = await workspaceTarget(body);
+            if (target && "ok" in target && target.ok === false) return target;
+            const pack = await loadCatalogPackage(body);
+            const catalogId = body.catalog === "skillsh" ? `skillsh:${body.source}/${body.skillId}` : `clawhub:${body.owner}/${body.slug}`;
+            return enqueueMutation(() => repositories.installCatalog(catalogId, pack, { root: body.root, ...body.workspace === void 0 ? {} : { workspace: body.workspace } }));
+          }, afterWrite);
+        }
         return enqueueMutation(() => {
           switch (path) {
             case "/api/dsh-skills-manager/repositories/add":
@@ -453,23 +484,30 @@ function apply(ctx) {
             case "/api/dsh-skills-manager/source-disable":
               return run(res, () => withScope(body, (scope) => setSourceEnabled(String(body.root || ""), false, log, scopedOptions(scope))), afterWrite);
             case "/api/dsh-skills-manager/category-create":
-              return run(res, () => withScope(body, (scope) => createCategory(String(body.root || ""), String(body.name || ""), log, scopedOptions(scope))), afterWrite);
+              return run(res, () => withScope(body, (scope) => createCategory(String(body.root || ""), String(body.name || ""), log, scopedOptions(scope))));
             case "/api/dsh-skills-manager/category-rename":
-              return run(res, () => withScope(body, (scope) => renameCategory(String(body.root || ""), String(body.id || ""), String(body.name || ""), log, scopedOptions(scope))), afterWrite);
+              return run(res, () => withScope(body, (scope) => renameCategory(String(body.root || ""), String(body.id || ""), String(body.name || ""), log, scopedOptions(scope))));
             case "/api/dsh-skills-manager/category-delete":
-              return run(res, () => withScope(body, (scope) => deleteCategory(String(body.root || ""), String(body.id || ""), log, scopedOptions(scope))), afterWrite);
+              return run(res, () => withScope(body, (scope) => deleteCategory(String(body.root || ""), String(body.id || ""), log, scopedOptions(scope))));
             case "/api/dsh-skills-manager/category-assign":
-              return run(res, () => withScope(body, (scope) => assignSkillCategory(String(body.root || ""), String(body.name || ""), String(body.category || ""), log, scopedOptions(scope))), afterWrite);
+              return run(res, () => withScope(body, (scope) => assignSkillCategory(String(body.root || ""), String(body.name || ""), String(body.category || ""), log, scopedOptions(scope))));
+            case "/api/dsh-skills-manager/category-move":
+              return run(res, () => withScope(body, (scope) => moveSkillInCategory(String(body.root || ""), String(body.name || ""), String(body.category || ""), body.targetName ? String(body.targetName) : void 0, body.position === void 0 ? "before" : String(body.position), log, scopedOptions(scope))));
             case "/api/dsh-skills-manager/category-enable":
               return run(res, () => withScope(body, (scope) => setCategoryEnabled(String(body.root || ""), String(body.category || ""), true, log, scopedOptions(scope))), afterWrite);
             case "/api/dsh-skills-manager/category-disable":
               return run(res, () => withScope(body, (scope) => setCategoryEnabled(String(body.root || ""), String(body.category || ""), false, log, scopedOptions(scope))), afterWrite);
             case "/api/dsh-skills-manager/delete":
-              return run(res, () => withScope(body, async (scope) => deleteSkill(await requestRoot(String(body.root || "dsh"), scope?.projectCwds), String(body.name || ""), log)), afterWrite);
+              return run(res, () => withScope(body, async (scope) => {
+                const target = await workspaceTarget(body);
+                if (target && "ok" in target && target.ok === false) return target;
+                const root = target ? target.root : await requestRoot(String(body.root || "dsh"), scope?.projectCwds);
+                return repositories.trashSkill(root, String(body.name || ""));
+              }), afterWrite);
             case "/api/dsh-skills-manager/trash-restore":
               return run(res, () => withScope(body, (scope) => repositories.restoreTrash(String(body.id || ""), { ...scope ?? {}, registeredWorkspaces: registeredWorkspacePaths(ctx) })), afterWrite);
             case "/api/dsh-skills-manager/trash-delete":
-              return run(res, () => permanentlyDeleteTrash(String(body.id || ""), log));
+              return run(res, () => repositories.permanentlyDeleteTrash(String(body.id || "")));
             case "/api/dsh-skills-manager/detail":
               return run(res, () => withScope(body, (scope) => skillDetail(String(body.root || "dsh"), String(body.name || ""), scope ? { ...scope, workspaceBound: true } : projectOptions())));
             case "/api/dsh-skills-manager/create":
@@ -479,7 +517,7 @@ function apply(ctx) {
                 return createSkill(
                   { name: body.name, description: body.description, body: body.body },
                   log,
-                  { root: target ? target.root : await requestRoot(String(body.root || "dsh")), ...userWriteOptions(body, target) }
+                  { root: target ? target.root : await requestRoot(String(body.root || "dsh")) }
                 );
               }, afterWrite);
             case "/api/dsh-skills-manager/import":
@@ -489,8 +527,7 @@ function apply(ctx) {
                 return importSkill(String(body.source || ""), log, {
                   conflict: body.conflict === "overwrite" ? "overwrite" : "skip",
                   dryRun: body.dryRun === true,
-                  ...target ? { root: target.root } : body.root === "agents" ? { root: await requestRoot("agents") } : {},
-                  ...userWriteOptions(body, target)
+                  ...target ? { root: target.root } : body.root === "agents" ? { root: await requestRoot("agents") } : {}
                 });
               }, body.dryRun === true ? void 0 : afterWrite);
             case "/api/dsh-skills-manager/upload":
@@ -499,8 +536,7 @@ function apply(ctx) {
                 if (target && "ok" in target && target.ok === false) return target;
                 return importUploadedSkill({ name: body.name, entries: body.entries, zip: body.zip }, log, {
                   conflict: body.conflict === "overwrite" ? "overwrite" : "skip",
-                  ...target ? { root: target.root } : body.root === "agents" ? { root: await requestRoot("agents") } : {},
-                  ...userWriteOptions(body, target)
+                  ...target ? { root: target.root } : body.root === "agents" ? { root: await requestRoot("agents") } : {}
                 });
               }, afterWrite);
             default: