allagents 0.5.2 → 0.6.0

package/dist/index.js

@@ -5324,8 +5324,8 @@ var require_pattern = __commonJS((exports) => {
   }
   exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
   function isAffectDepthOfReadingPattern(pattern) {
-    const basename = path3.basename(pattern);
-    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+    const basename2 = path3.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename2);
   }
   exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
   function expandPatternsWithBraceExpansion(patterns) {
@@ -11059,7 +11059,7 @@ import { dirname as dirname7, join as join12 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/core/workspace.ts
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4, copyFile as copyFile2 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile4, copyFile as copyFile2 } from "node:fs/promises";
 import { existsSync as existsSync7 } from "node:fs";
 import { join as join8, resolve as resolve5, dirname as dirname5, relative as relative2, sep, isAbsolute as isAbsolute2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -19558,11 +19558,27 @@ async function verifyGitHubUrlExists(source) {
 }
 
 // src/core/plugin.ts
-import { mkdir, readdir, stat } from "node:fs/promises";
+import { mkdir, readdir, stat, readFile as readFile2 } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { dirname, join, resolve as resolve2 } from "node:path";
-async function fetchPlugin(url, options2 = {}) {
+import { basename, dirname, join, resolve as resolve2 } from "node:path";
+
+// src/models/plugin-config.ts
+var PluginManifestSchema = exports_external.object({
+  name: exports_external.string(),
+  version: exports_external.string(),
+  description: exports_external.string(),
+  author: exports_external.string().optional(),
+  license: exports_external.string().optional()
+});
+
+// src/core/plugin.ts
+async function fetchPlugin(url, options2 = {}, deps = {}) {
   const { force = false, branch } = options2;
+  const {
+    execa: execaFn = execa,
+    existsSync: existsSyncFn = existsSync,
+    mkdir: mkdirFn = mkdir
+  } = deps;
   const validation = validatePluginSource(url);
   if (!validation.valid) {
     return {
@@ -19584,7 +19600,7 @@ async function fetchPlugin(url, options2 = {}) {
   const { owner, repo } = parsed;
   const cachePath = getPluginCachePath(owner, repo, branch);
   try {
-    await execa("gh", ["--version"]);
+    await execaFn("gh", ["--version"]);
   } catch {
     return {
       success: false,
@@ -19594,7 +19610,7 @@ async function fetchPlugin(url, options2 = {}) {
   Install: https://cli.github.com`
     };
   }
-  const isCached = existsSync(cachePath);
+  const isCached = existsSyncFn(cachePath);
   if (isCached && !force) {
     return {
       success: true,
@@ -19604,7 +19620,7 @@ async function fetchPlugin(url, options2 = {}) {
   }
   try {
     if (isCached && force) {
-      await execa("git", ["pull"], { cwd: cachePath });
+      await execaFn("git", ["pull"], { cwd: cachePath });
       return {
         success: true,
         action: "updated",
@@ -19612,11 +19628,11 @@ async function fetchPlugin(url, options2 = {}) {
       };
     }
     const parentDir = dirname(cachePath);
-    await mkdir(parentDir, { recursive: true });
+    await mkdirFn(parentDir, { recursive: true });
     if (branch) {
-      await execa("gh", ["repo", "clone", `${owner}/${repo}`, cachePath, "--", "--branch", branch]);
+      await execaFn("gh", ["repo", "clone", `${owner}/${repo}`, cachePath, "--", "--branch", branch]);
     } else {
-      await execa("gh", ["repo", "clone", `${owner}/${repo}`, cachePath]);
+      await execaFn("gh", ["repo", "clone", `${owner}/${repo}`, cachePath]);
     }
     return {
       success: true,
@@ -19666,9 +19682,23 @@ async function fetchPlugin(url, options2 = {}) {
     };
   }
 }
+async function getPluginName(pluginPath) {
+  const manifestPath = join(pluginPath, "plugin.json");
+  if (existsSync(manifestPath)) {
+    try {
+      const content = await readFile2(manifestPath, "utf-8");
+      const manifest = JSON.parse(content);
+      const result = PluginManifestSchema.safeParse(manifest);
+      if (result.success && result.data.name) {
+        return result.data.name;
+      }
+    } catch {}
+  }
+  return basename(pluginPath);
+}
 
 // src/core/transform.ts
-import { readFile as readFile3, writeFile, mkdir as mkdir2, cp, readdir as readdir2 } from "node:fs/promises";
+import { readFile as readFile4, writeFile, mkdir as mkdir2, cp, readdir as readdir2 } from "node:fs/promises";
 import { existsSync as existsSync3 } from "node:fs";
 import { join as join4, dirname as dirname2 } from "node:path";
 
@@ -19752,7 +19782,7 @@ var CLIENT_MAPPINGS = {
 
 // src/validators/skill.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 
@@ -19776,7 +19806,7 @@ async function validateSkill(skillDir) {
     };
   }
   try {
-    const content = await readFile2(skillMdPath, "utf-8");
+    const content = await readFile3(skillMdPath, "utf-8");
     const { data: frontmatter } = import_gray_matter.default(content);
     if (!frontmatter || Object.keys(frontmatter).length === 0) {
       return {
@@ -19826,7 +19856,7 @@ async function ensureWorkspaceRules(filePath, rules) {
 `, "utf-8");
     return;
   }
-  const content = await readFile3(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   const startIndex = content.indexOf(startMarker);
   const endIndex = content.indexOf(endMarker);
   if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
@@ -19862,7 +19892,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
       return { source: sourcePath, destination: destPath, action: "copied" };
     }
     try {
-      const content = await readFile3(sourcePath, "utf-8");
+      const content = await readFile4(sourcePath, "utf-8");
       await writeFile(destPath, content, "utf-8");
       return { source: sourcePath, destination: destPath, action: "copied" };
     } catch (error) {
@@ -19877,7 +19907,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   return Promise.all(copyPromises);
 }
 async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
-  const { dryRun = false } = options2;
+  const { dryRun = false, skillNameMap } = options2;
   const mapping = CLIENT_MAPPINGS[client];
   const results = [];
   if (!mapping.skillsPath) {
@@ -19895,7 +19925,8 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
   const skillDirs = entries.filter((e) => e.isDirectory());
   const copyPromises = skillDirs.map(async (entry) => {
     const skillSourcePath = join4(sourceDir, entry.name);
-    const skillDestPath = join4(destDir, entry.name);
+    const resolvedName = skillNameMap?.get(entry.name) ?? entry.name;
+    const skillDestPath = join4(destDir, resolvedName);
     const validation = await validateSkill(skillSourcePath);
     if (!validation.valid) {
       return {
@@ -19930,6 +19961,20 @@ async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
   });
   return Promise.all(copyPromises);
 }
+async function collectPluginSkills(pluginPath, pluginSource) {
+  const skillsDir = join4(pluginPath, "skills");
+  if (!existsSync3(skillsDir)) {
+    return [];
+  }
+  const entries = await readdir2(skillsDir, { withFileTypes: true });
+  const skillDirs = entries.filter((e) => e.isDirectory());
+  return skillDirs.map((entry) => ({
+    folderName: entry.name,
+    skillPath: join4(skillsDir, entry.name),
+    pluginPath,
+    pluginSource
+  }));
+}
 async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
   const { dryRun = false } = options2;
   const mapping = CLIENT_MAPPINGS[client];
@@ -19984,7 +20029,7 @@ async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
       return { source: sourcePath, destination: destPath, action: "copied" };
     }
     try {
-      const content = await readFile3(sourcePath, "utf-8");
+      const content = await readFile4(sourcePath, "utf-8");
       await writeFile(destPath, content, "utf-8");
       return { source: sourcePath, destination: destPath, action: "copied" };
     } catch (error) {
@@ -19999,11 +20044,12 @@ async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
   return Promise.all(copyPromises);
 }
 async function copyPluginToWorkspace(pluginPath, workspacePath, client, options2 = {}) {
+  const { skillNameMap, ...baseOptions } = options2;
   const [commandResults, skillResults, hookResults, agentResults] = await Promise.all([
-    copyCommands(pluginPath, workspacePath, client, options2),
-    copySkills(pluginPath, workspacePath, client, options2),
-    copyHooks(pluginPath, workspacePath, client, options2),
-    copyAgents(pluginPath, workspacePath, client, options2)
+    copyCommands(pluginPath, workspacePath, client, baseOptions),
+    copySkills(pluginPath, workspacePath, client, { ...baseOptions, ...skillNameMap && { skillNameMap } }),
+    copyHooks(pluginPath, workspacePath, client, baseOptions),
+    copyAgents(pluginPath, workspacePath, client, baseOptions)
   ]);
   return [...commandResults, ...skillResults, ...hookResults, ...agentResults];
 }
@@ -20119,7 +20165,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
         }
         try {
           await mkdir2(dirname2(destPath), { recursive: true });
-          const content = await readFile3(resolved.sourcePath, "utf-8");
+          const content = await readFile4(resolved.sourcePath, "utf-8");
           await writeFile(destPath, content, "utf-8");
           results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
           if (AGENT_FILES2.includes(resolved.relativePath)) {
@@ -20190,7 +20236,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
     }
     try {
       await mkdir2(dirname2(destPath), { recursive: true });
-      const content = await readFile3(srcPath, "utf-8");
+      const content = await readFile4(srcPath, "utf-8");
       await writeFile(destPath, content, "utf-8");
       results.push({ source: srcPath, destination: destPath, action: "copied" });
       if (AGENT_FILES2.includes(entry.dest)) {
@@ -20223,10 +20269,153 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
   return results;
 }
 
+// src/utils/hash.ts
+import { createHash } from "node:crypto";
+function getShortId(input) {
+  return createHash("sha256").update(input).digest("hex").substring(0, 6);
+}
+
+// src/utils/source-parser.ts
+function extractOrgFromSource(source) {
+  if (!source || source.trim() === "") {
+    return null;
+  }
+  const trimmedSource = source.trim();
+  if (isLocalPath(trimmedSource)) {
+    return null;
+  }
+  if (trimmedSource.startsWith("github:")) {
+    return parseOrgFromPrefix(trimmedSource.slice("github:".length));
+  }
+  if (trimmedSource.startsWith("gh:")) {
+    return parseOrgFromPrefix(trimmedSource.slice("gh:".length));
+  }
+  const urlMatch = trimmedSource.match(/^(?:https?:\/\/)?(?:www\.)?github\.com\/([^/]+)(?:\/|$)/);
+  if (urlMatch?.[1]) {
+    return validateOrg(urlMatch[1]);
+  }
+  if (trimmedSource.includes("/") && !trimmedSource.includes("://")) {
+    const firstSlashIndex = trimmedSource.indexOf("/");
+    const potentialOrg = trimmedSource.slice(0, firstSlashIndex);
+    return validateOrg(potentialOrg);
+  }
+  return null;
+}
+function isLocalPath(source) {
+  if (source.startsWith(".")) {
+    return true;
+  }
+  if (source.startsWith("/")) {
+    return true;
+  }
+  if (/^[a-zA-Z]:[\\/]/.test(source)) {
+    return true;
+  }
+  if (source.includes("\\")) {
+    return true;
+  }
+  return false;
+}
+function parseOrgFromPrefix(prefixContent) {
+  const withoutBranch = prefixContent.split("#")[0] || "";
+  const slashIndex = withoutBranch.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  const org = withoutBranch.slice(0, slashIndex);
+  return validateOrg(org);
+}
+function validateOrg(org) {
+  if (!org || org.trim() === "") {
+    return null;
+  }
+  const trimmedOrg = org.trim();
+  const validOrgPattern = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/;
+  if (!validOrgPattern.test(trimmedOrg)) {
+    if (trimmedOrg.length === 1 && /^[a-zA-Z0-9]$/.test(trimmedOrg)) {
+      return trimmedOrg;
+    }
+    return null;
+  }
+  if (trimmedOrg.includes("--")) {
+    return null;
+  }
+  return trimmedOrg;
+}
+
+// src/utils/skill-name-resolver.ts
+function getSkillKey(entry) {
+  return `${entry.pluginSource}::${entry.pluginName}::${entry.folderName}`;
+}
+function getDisambiguatorPrefix(pluginSource) {
+  const org = extractOrgFromSource(pluginSource);
+  if (org) {
+    return org;
+  }
+  return getShortId(pluginSource);
+}
+function resolveSkillNames(skills) {
+  const resolved = [];
+  const nameMap = new Map;
+  const byFolderName = new Map;
+  for (const skill of skills) {
+    const existing = byFolderName.get(skill.folderName) || [];
+    existing.push(skill);
+    byFolderName.set(skill.folderName, existing);
+  }
+  for (const [folderName, group] of byFolderName) {
+    if (group.length === 1) {
+      const skill = group[0];
+      if (skill) {
+        const resolvedEntry = {
+          original: skill,
+          resolvedName: folderName,
+          wasRenamed: false
+        };
+        resolved.push(resolvedEntry);
+        nameMap.set(getSkillKey(skill), folderName);
+      }
+    } else {
+      const byPluginName = new Map;
+      for (const skill of group) {
+        const existing = byPluginName.get(skill.pluginName) || [];
+        existing.push(skill);
+        byPluginName.set(skill.pluginName, existing);
+      }
+      const hasPluginNameConflict = Array.from(byPluginName.values()).some((pluginGroup) => pluginGroup.length > 1);
+      if (!hasPluginNameConflict) {
+        for (const skill of group) {
+          const resolvedName = `${skill.pluginName}_${folderName}`;
+          const resolvedEntry = {
+            original: skill,
+            resolvedName,
+            wasRenamed: true
+          };
+          resolved.push(resolvedEntry);
+          nameMap.set(getSkillKey(skill), resolvedName);
+        }
+      } else {
+        for (const skill of group) {
+          const prefix = getDisambiguatorPrefix(skill.pluginSource);
+          const resolvedName = `${prefix}_${skill.pluginName}_${folderName}`;
+          const resolvedEntry = {
+            original: skill,
+            resolvedName,
+            wasRenamed: true
+          };
+          resolved.push(resolvedEntry);
+          nameMap.set(getSkillKey(skill), resolvedName);
+        }
+      }
+    }
+  }
+  return { resolved, nameMap };
+}
+
 // src/core/marketplace.ts
-import { mkdir as mkdir3, readFile as readFile4, readdir as readdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile5, readdir as readdir3, writeFile as writeFile2 } from "node:fs/promises";
 import { existsSync as existsSync4 } from "node:fs";
-import { basename, join as join5, resolve as resolve3 } from "node:path";
+import { basename as basename2, join as join5, resolve as resolve3 } from "node:path";
 var WELL_KNOWN_MARKETPLACES = {
   "claude-plugins-official": "anthropics/claude-plugins-official"
 };
@@ -20246,7 +20435,7 @@ async function loadRegistry() {
     return { version: 1, marketplaces: {} };
   }
   try {
-    const content = await readFile4(registryPath, "utf-8");
+    const content = await readFile5(registryPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return { version: 1, marketplaces: {} };
@@ -20285,7 +20474,7 @@ function parseMarketplaceSource(source) {
   }
   if (source.startsWith("/") || source.startsWith(".")) {
     const absPath = resolve3(source);
-    const name = basename(absPath) || "local";
+    const name = basename2(absPath) || "local";
     return {
       type: "local",
       location: absPath,
@@ -20526,7 +20715,7 @@ function getWellKnownMarketplaces() {
 }
 
 // src/core/sync-state.ts
-import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir4 } from "node:fs/promises";
+import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir4 } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
 import { join as join6, dirname as dirname3 } from "node:path";
 
@@ -20547,7 +20736,7 @@ async function loadSyncState(workspacePath) {
     return null;
   }
   try {
-    const content = await readFile5(statePath, "utf-8");
+    const content = await readFile6(statePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = SyncStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -20581,7 +20770,9 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
     return [];
   }
   const result = [];
-  for (const client of clients) {
+  const previousClients = Object.keys(state.files);
+  const clientsToProcess = [...new Set([...clients, ...previousClients])];
+  for (const client of clientsToProcess) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
@@ -20828,10 +21019,10 @@ async function validatePlugin(pluginSource, workspacePath, force) {
 async function validateAllPlugins(plugins, workspacePath, force) {
   return Promise.all(plugins.map((plugin) => validatePlugin(plugin, workspacePath, force)));
 }
-async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun) {
+async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap) {
   const copyResults = [];
   for (const client of clients) {
-    const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, { dryRun });
+    const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, { dryRun, ...skillNameMap && { skillNameMap } });
     copyResults.push(...results);
   }
   const hasFailures = copyResults.some((r) => r.action === "failed");
@@ -20842,6 +21033,47 @@ async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryR
     copyResults
   };
 }
+async function collectAllSkills(validatedPlugins) {
+  const allSkills = [];
+  for (const plugin of validatedPlugins) {
+    const pluginName = await getPluginName(plugin.resolved);
+    const skills = await collectPluginSkills(plugin.resolved, plugin.plugin);
+    for (const skill of skills) {
+      allSkills.push({
+        folderName: skill.folderName,
+        pluginName,
+        pluginSource: plugin.plugin,
+        pluginPath: plugin.resolved
+      });
+    }
+  }
+  return allSkills;
+}
+function buildPluginSkillNameMaps(allSkills) {
+  const skillEntries = allSkills.map((skill) => ({
+    folderName: skill.folderName,
+    pluginName: skill.pluginName,
+    pluginSource: skill.pluginSource
+  }));
+  const resolution = resolveSkillNames(skillEntries);
+  const pluginMaps = new Map;
+  for (let i2 = 0;i2 < allSkills.length; i2++) {
+    const skill = allSkills[i2];
+    const entry = skillEntries[i2];
+    if (!skill || !entry)
+      continue;
+    const resolvedName = resolution.nameMap.get(getSkillKey(entry));
+    if (resolvedName) {
+      let pluginMap = pluginMaps.get(skill.pluginPath);
+      if (!pluginMap) {
+        pluginMap = new Map;
+        pluginMaps.set(skill.pluginPath, pluginMap);
+      }
+      pluginMap.set(skill.folderName, resolvedName);
+    }
+  }
+  return pluginMaps;
+}
 async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   const { force = false, dryRun = false, workspaceSourceBase } = options2;
   const configDir = join7(workspacePath, CONFIG_DIR);
@@ -20918,7 +21150,12 @@ ${errors2}`
   if (!dryRun) {
     await selectivePurgeWorkspace(workspacePath, previousState, config.clients);
   }
-  const pluginResults = await Promise.all(validatedPlugins.map((validatedPlugin) => copyValidatedPlugin(validatedPlugin, workspacePath, config.clients, dryRun)));
+  const allSkills = await collectAllSkills(validatedPlugins);
+  const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
+  const pluginResults = await Promise.all(validatedPlugins.map((validatedPlugin) => {
+    const skillNameMap = pluginSkillMaps.get(validatedPlugin.resolved);
+    return copyValidatedPlugin(validatedPlugin, workspacePath, config.clients, dryRun, skillNameMap);
+  }));
   let workspaceFileResults = [];
   if (config.workspace) {
     const sourcePath = validatedWorkspaceSource?.resolved;
@@ -21010,7 +21247,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     }
   }
   const hasFailures = pluginResults.some((r) => !r.success) || totalFailed > 0;
-  if (!hasFailures && !dryRun) {
+  if (!dryRun) {
     const allCopyResults = [
       ...pluginResults.flatMap((r) => r.copyResults),
       ...workspaceFileResults
@@ -21298,7 +21535,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             sourceDir = parentDir;
           }
         }
-        workspaceYamlContent = await readFile6(sourceYamlPath, "utf-8");
+        workspaceYamlContent = await readFile7(sourceYamlPath, "utf-8");
         if (sourceDir) {
           const parsed2 = load(workspaceYamlContent);
           const workspace = parsed2?.workspace;
@@ -21317,7 +21554,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       if (!existsSync7(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
-      workspaceYamlContent = await readFile6(defaultYamlPath, "utf-8");
+      workspaceYamlContent = await readFile7(defaultYamlPath, "utf-8");
     }
     await writeFile4(configPath, workspaceYamlContent, "utf-8");
     const copiedAgentFiles = [];
@@ -21339,7 +21576,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       for (const agentFile of AGENT_FILES) {
         const sourcePath = join8(effectiveSourceDir, agentFile);
         if (existsSync7(sourcePath)) {
-          const content = await readFile6(sourcePath, "utf-8");
+          const content = await readFile7(sourcePath, "utf-8");
           await writeFile4(join8(absoluteTarget, agentFile), content, "utf-8");
           copiedAgentFiles.push(agentFile);
         }
@@ -21449,7 +21686,7 @@ function getPluginStatus(parsed) {
 }
 
 // src/core/workspace-modify.ts
-import { readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
 import { existsSync as existsSync9 } from "node:fs";
 import { join as join10 } from "node:path";
 async function addPlugin(plugin, workspacePath = process.cwd()) {
@@ -21565,7 +21802,7 @@ async function ensureMarketplaceRegistered(spec) {
 }
 async function addPluginToConfig(plugin, configPath, autoRegistered) {
   try {
-    const content = await readFile7(configPath, "utf-8");
+    const content = await readFile8(configPath, "utf-8");
     const config = load(content);
     if (config.plugins.includes(plugin)) {
       return {
@@ -21597,7 +21834,7 @@ async function removePlugin(plugin, workspacePath = process.cwd()) {
     };
   }
   try {
-    const content = await readFile7(configPath, "utf-8");
+    const content = await readFile8(configPath, "utf-8");
     const config = load(content);
     let index = config.plugins.indexOf(plugin);
     if (index === -1 && isPluginSpec(plugin) === false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {
@@ -14,7 +14,7 @@
     "docs:install": "bun install --cwd docs",
     "docs:build": "bun run --cwd docs build",
     "dev": "bun run src/cli/index.ts",
-    "test": "bun test tests/unit/validators tests/unit/utils tests/unit/models && bun test tests/unit/core/marketplace.test.ts tests/unit/core/sync.test.ts tests/unit/core/transform-glob.test.ts tests/unit/core/github-fetch.test.ts && bun test tests/unit/core/plugin.test.ts",
+    "test": "bun test",
     "test:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
     "test:integration": "bats tests/integration/*.bats",
@@ -24,7 +24,8 @@
     "format": "biome format --write src",
     "check": "biome check src",
     "check:fix": "biome check --write src",
-    "prepare": "bun run build && (test -d .git && bunx prek install -t pre-push || true)"
+    "prepare": "bun run build && (test -d .git && bunx prek install -t pre-push || true)",
+    "release": "bun run scripts/release.ts"
   },
   "keywords": [
     "cli",