allagents 1.0.4 → 1.0.7

package/README.md

@@ -44,11 +44,11 @@ CLI tool for managing multi-repo AI agent workspaces with plugin synchronization
 ## Installation
 
 ```bash
-# Using bun
-bun install -g allagents
+# Using npm
+npm install -g allagents
 
-# Or run directly
-bunx allagents
+# Or run directly without installing
+npx allagents
 ```
 
 ## Quick Start

package/dist/index.js

@@ -6378,7 +6378,7 @@ var require_parse = __commonJS((exports, module) => {
   var token;
   var key;
   var root;
-  module.exports = function parse2(text, reviver) {
+  module.exports = function parse(text, reviver) {
     source = String(text);
     parseState = "start";
     stack = [];
@@ -13446,7 +13446,7 @@ function gitInstanceFactory(baseDir, options2) {
 }
 var import_file_exists, import_debug, import_promise_deferred, import_promise_deferred2, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __esm2 = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
-}, __commonJS2 = (cb, mod) => function __require2() {
+}, __commonJS2 = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 }, __export2 = (target, all) => {
   for (var name in all)
@@ -21933,7 +21933,7 @@ var require_is_extendable = __commonJS((exports, module) => {
 // node_modules/extend-shallow/index.js
 var require_extend_shallow = __commonJS((exports, module) => {
   var isObject2 = require_is_extendable();
-  module.exports = function extend3(o) {
+  module.exports = function extend(o) {
     if (!isObject2(o)) {
       o = {};
     }
@@ -22127,7 +22127,7 @@ var require_exception = __commonJS((exports, module) => {
   }
   YAMLException2.prototype = Object.create(Error.prototype);
   YAMLException2.prototype.constructor = YAMLException2;
-  YAMLException2.prototype.toString = function toString2(compact) {
+  YAMLException2.prototype.toString = function toString(compact) {
     var result = this.name + ": ";
     result += this.reason || "(unknown reason)";
     if (!compact && this.mark) {
@@ -22180,7 +22180,7 @@ var require_mark = __commonJS((exports, module) => {
     return common2.repeat(" ", indent) + head + snippet2 + tail + `
 ` + common2.repeat(" ", indent + this.position - start + head.length) + "^";
   };
-  Mark.prototype.toString = function toString2(compact) {
+  Mark.prototype.toString = function toString(compact) {
     var snippet2, where = "";
     if (this.name) {
       where += 'in "' + this.name + '" ';
@@ -23275,7 +23275,7 @@ var require_loader = __commonJS((exports, module) => {
     }
   }
   var directiveHandlers2 = {
-    YAML: function handleYamlDirective2(state, name, args) {
+    YAML: function handleYamlDirective(state, name, args) {
       var match, major, minor;
       if (state.version !== null) {
         throwError2(state, "duplication of %YAML directive");
@@ -23298,7 +23298,7 @@ var require_loader = __commonJS((exports, module) => {
         throwWarning2(state, "unsupported YAML version of the document");
       }
     },
-    TAG: function handleTagDirective2(state, name, args) {
+    TAG: function handleTagDirective(state, name, args) {
       var handle, prefix;
       if (args.length !== 2) {
         throwError2(state, "TAG directive accepts exactly two arguments");
@@ -33416,7 +33416,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.0.4",
+    version: "1.0.7",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -33443,7 +33443,8 @@ var init_package = __esm(() => {
       prepare: "bun run build && (test -d .git && bunx prek install -t pre-push || true)",
       release: "bun run scripts/release.ts",
       "release:next": "bun run scripts/release.ts next",
-      "publish:next": "bun run build && bun publish --tag next"
+      "publish:next": "bun run build && bun publish --tag next",
+      "promote:latest": "bun scripts/tag-channel.ts latest"
     },
     keywords: [
       "cli",
@@ -33489,13 +33490,13 @@ var init_package = __esm(() => {
 });
 
 // src/cli/update-check.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import { join as join24 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 async function getCachedUpdateInfo(path3) {
   const filePath = path3 ?? join24(getHomeDir(), CONFIG_DIR, CACHE_FILE);
   try {
-    const raw = await readFile14(filePath, "utf-8");
+    const raw = await readFile15(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -36002,6 +36003,7 @@ init_user_workspace();
 init_skills();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
 import { existsSync as existsSync19 } from "node:fs";
+import { readFile as readFile13 } from "node:fs/promises";
 import { join as join22 } from "node:path";
 
 // src/cli/metadata/plugin-skills.ts
@@ -36046,19 +36048,37 @@ var skillsRemoveMeta = {
 };
 var skillsAddMeta = {
   command: "plugin skills add",
-  description: "Re-enable a previously disabled skill",
-  whenToUse: "To re-enable a skill that was previously disabled",
+  description: "Add a skill from a plugin, or re-enable a previously disabled skill",
+  whenToUse: "To add a skill from a GitHub repo or marketplace plugin, or to re-enable a skill that was previously disabled",
   examples: [
-    "allagents plugin skills add brainstorming",
-    "allagents plugin skills add brainstorming --plugin superpowers"
+    "allagents skills add reddit --from ReScienceLab/opc-skills",
+    "allagents skills add https://github.com/owner/repo/tree/main/skills/my-skill",
+    "allagents skills add brainstorming",
+    "allagents skills add brainstorming --plugin superpowers"
   ],
   expectedOutput: "Confirms skill was enabled and runs sync",
   positionals: [
-    { name: "skill", type: "string", required: true, description: "Skill name to enable" }
+    {
+      name: "skill",
+      type: "string",
+      required: true,
+      description: "Skill name to add, or a GitHub URL pointing to a skill"
+    }
   ],
   options: [
     { flag: "--scope", short: "-s", type: "string", description: 'Scope: "project" (default) or "user"' },
-    { flag: "--plugin", short: "-p", type: "string", description: "Plugin name (required if skill exists in multiple plugins)" }
+    {
+      flag: "--plugin",
+      short: "-p",
+      type: "string",
+      description: "Plugin name (required if skill exists in multiple plugins)"
+    },
+    {
+      flag: "--from",
+      short: "-f",
+      type: "string",
+      description: "Plugin source (GitHub URL, owner/repo, or plugin@marketplace) to install if the skill is not already available"
+    }
   ],
   outputSchema: {
     skill: "string",
@@ -36069,6 +36089,11 @@ var skillsAddMeta = {
 
 // src/cli/commands/plugin-skills.ts
 init_constants();
+init_plugin_path();
+init_plugin();
+init_skill();
+init_marketplace();
+init_marketplace_manifest_parser();
 function hasProjectConfig(dir) {
   return existsSync19(join22(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
@@ -36079,6 +36104,35 @@ function resolveScope(cwd) {
     return "project";
   return "user";
 }
+function resolveSkillFromUrl(skill) {
+  if (!isGitHubUrl(skill))
+    return null;
+  const parsed = parseGitHubUrl(skill);
+  if (!parsed)
+    return null;
+  if (parsed.subpath) {
+    const segments = parsed.subpath.split("/").filter(Boolean);
+    const name = segments[segments.length - 1];
+    if (!name)
+      return null;
+    return { skill: name, from: skill, parsed };
+  }
+  return { skill: parsed.repo, from: skill, parsed };
+}
+async function resolveSkillNameFromRepo(url, parsed, fallbackName, fetchFn = fetchPlugin) {
+  const fetchResult = await fetchFn(url, {
+    ...parsed.branch && { branch: parsed.branch }
+  });
+  if (!fetchResult.success)
+    return fallbackName;
+  try {
+    const skillMd = await readFile13(join22(fetchResult.cachePath, "SKILL.md"), "utf-8");
+    const metadata = parseSkillMetadata(skillMd);
+    return metadata?.name ?? fallbackName;
+  } catch {
+    return fallbackName;
+  }
+}
 function groupSkillsByPlugin(skills) {
   const grouped = new Map;
   for (const skill of skills) {
@@ -36303,6 +36357,148 @@ Syncing workspace...
     }
   }
 });
+async function installSkillFromSource(opts) {
+  const { skill, from, isUser, workspacePath } = opts;
+  if (!isJsonMode()) {
+    console.log(`Skill '${skill}' not found. Installing from: ${from}...`);
+  }
+  const parsed = isGitHubUrl(from) ? parseGitHubUrl(from) : null;
+  const fetchResult = await fetchPlugin(from, {
+    ...parsed?.branch && { branch: parsed.branch }
+  });
+  if (!fetchResult.success) {
+    return { success: false, error: `Failed to fetch '${from}': ${fetchResult.error ?? "Unknown error"}` };
+  }
+  const manifestResult = await parseMarketplaceManifest(fetchResult.cachePath);
+  if (manifestResult.success) {
+    return installSkillViaMarketplace({ skill, from, isUser, workspacePath });
+  }
+  return installSkillDirect({ skill, from, isUser, workspacePath, cachePath: fetchResult.cachePath });
+}
+async function installSkillViaMarketplace(opts) {
+  const { skill, from, isUser, workspacePath } = opts;
+  if (!isJsonMode()) {
+    console.log("Detected marketplace. Registering...");
+  }
+  const parsed = isGitHubUrl(from) ? parseGitHubUrl(from) : null;
+  const scopeOptions = isUser ? undefined : { scope: "project", workspacePath };
+  let marketplaceName;
+  const mktResult = await addMarketplace(from, parsed?.branch ? `${parsed.repo}-${parsed.branch}` : undefined, parsed?.branch ?? undefined, undefined, scopeOptions);
+  if (mktResult.success) {
+    marketplaceName = mktResult.marketplace?.name;
+  } else if (mktResult.error?.includes("already exists") || mktResult.alreadyRegistered) {
+    const sourceLocation = parsed ? `${parsed.owner}/${parsed.repo}` : undefined;
+    const existing = await findMarketplace(parsed?.repo ?? from, sourceLocation, isUser ? undefined : workspacePath);
+    if (existing) {
+      marketplaceName = existing.name;
+      if (!isJsonMode()) {
+        console.log(`Marketplace '${marketplaceName}' already registered. Updating...`);
+      }
+      await updateMarketplace(marketplaceName, isUser ? undefined : workspacePath);
+    }
+  }
+  if (!marketplaceName) {
+    return { success: false, error: `Failed to register marketplace: ${mktResult.error ?? "Unknown error"}` };
+  }
+  const mktPlugins = await listMarketplacePlugins(marketplaceName, isUser ? undefined : workspacePath);
+  if (mktPlugins.plugins.length === 0) {
+    return { success: false, error: `No plugins found in marketplace '${marketplaceName}'.` };
+  }
+  let targetPluginName = null;
+  const allAvailableSkills = [];
+  for (const mktPlugin of mktPlugins.plugins) {
+    const skillNames = await discoverSkillNames(mktPlugin.path);
+    allAvailableSkills.push(...skillNames);
+    if (!targetPluginName && skillNames.includes(skill)) {
+      targetPluginName = mktPlugin.name;
+    }
+  }
+  if (!targetPluginName) {
+    return {
+      success: false,
+      error: `Skill '${skill}' not found in marketplace '${marketplaceName}'.
+
+Available skills: ${allAvailableSkills.join(", ") || "none"}`
+    };
+  }
+  const pluginSpec = `${targetPluginName}@${marketplaceName}`;
+  if (!isJsonMode()) {
+    console.log(`Found skill '${skill}' in plugin '${targetPluginName}'. Installing ${pluginSpec}...`);
+  }
+  const installResult = isUser ? await addUserPlugin(pluginSpec) : await addPlugin(pluginSpec, workspacePath);
+  if (!installResult.success) {
+    if (!installResult.error?.includes("already exists") && !installResult.error?.includes("duplicates existing")) {
+      return { success: false, error: `Failed to install plugin '${pluginSpec}': ${installResult.error ?? "Unknown error"}` };
+    }
+    if (!isJsonMode()) {
+      console.log(`Plugin '${pluginSpec}' already installed.`);
+    }
+  }
+  return applySkillAllowlist({ skill, pluginName: targetPluginName, isUser, workspacePath });
+}
+async function installSkillDirect(opts) {
+  const { skill, from, isUser, workspacePath, cachePath } = opts;
+  const availableSkills = await discoverSkillNames(cachePath);
+  if (!availableSkills.includes(skill)) {
+    return {
+      success: false,
+      error: `Skill '${skill}' not found in plugin '${from}'.
+
+Available skills: ${availableSkills.join(", ") || "none"}
+
+Tip: run \`allagents skills list\` to see all installed skills.`
+    };
+  }
+  const installResult = isUser ? await addUserPlugin(from) : await addPlugin(from, workspacePath);
+  if (!installResult.success) {
+    if (!installResult.error?.includes("already exists") && !installResult.error?.includes("duplicates existing")) {
+      return { success: false, error: `Failed to install plugin '${from}': ${installResult.error ?? "Unknown error"}` };
+    }
+    if (!isJsonMode()) {
+      console.log("Plugin already installed.");
+    }
+  }
+  const pluginName = getPluginName(cachePath);
+  return applySkillAllowlist({ skill, pluginName, isUser, workspacePath });
+}
+async function applySkillAllowlist(opts) {
+  const { skill, pluginName, isUser, workspacePath } = opts;
+  const allSkills = await getAllSkillsFromPlugins(workspacePath);
+  const pluginSkills = allSkills.filter((s) => s.pluginName === pluginName);
+  const currentMode = pluginSkills[0]?.pluginSkillsMode ?? "none";
+  if (currentMode === "allowlist") {
+    const skillKey = `${pluginName}:${skill}`;
+    const addResult = isUser ? await addUserEnabledSkill(skillKey) : await addEnabledSkill(skillKey, workspacePath);
+    if (!addResult.success) {
+      if (!addResult.error?.includes("already enabled")) {
+        return { success: false, error: `Failed to enable skill: ${addResult.error ?? "Unknown error"}` };
+      }
+    }
+  } else {
+    const setModeResult = isUser ? await setUserPluginSkillsMode(pluginName, "allowlist", [skill]) : await setPluginSkillsMode(pluginName, "allowlist", [skill], workspacePath);
+    if (!setModeResult.success) {
+      return { success: false, error: `Failed to configure skill allowlist: ${setModeResult.error ?? "Unknown error"}` };
+    }
+  }
+  if (!isJsonMode()) {
+    console.log(`✓ Enabled skill: ${skill} (${pluginName})`);
+    console.log(`
+Syncing workspace...
+`);
+  }
+  const syncResult = isUser ? await syncUserWorkspace() : await syncWorkspace(workspacePath);
+  if (!syncResult.success) {
+    return { success: false, error: "Sync failed" };
+  }
+  return {
+    success: true,
+    pluginName,
+    syncResult: {
+      copied: syncResult.totalCopied,
+      failed: syncResult.totalFailed
+    }
+  };
+}
 var addCmd = import_cmd_ts3.command({
   name: "add",
   description: buildDescription(skillsAddMeta),
@@ -36327,60 +36523,73 @@ var addCmd = import_cmd_ts3.command({
       description: "Plugin source to install if the skill is not already available"
     })
   },
-  handler: async ({ skill, scope, plugin, from }) => {
+  handler: async ({ skill: skillArg, scope, plugin, from: fromArg }) => {
     try {
+      let skill = skillArg;
+      let from = fromArg;
       const isUser = scope === "user" || !scope && resolveScope(process.cwd()) === "user";
       const workspacePath = isUser ? getHomeDir() : process.cwd();
-      let matches = await findSkillByName(skill, workspacePath);
-      if (matches.length === 0) {
+      const urlResolved = resolveSkillFromUrl(skill);
+      if (urlResolved) {
         if (from) {
-          if (!isJsonMode()) {
-            console.log(`Skill '${skill}' not found. Installing plugin: ${from}...`);
-          }
-          const installResult = isUser ? await addUserPlugin(from) : await addPlugin(from, workspacePath);
-          if (!installResult.success) {
-            const error = `Failed to install plugin '${from}': ${installResult.error ?? "Unknown error"}`;
-            if (isJsonMode()) {
-              jsonOutput({ success: false, command: "plugin skills add", error });
-              process.exit(1);
-            }
-            console.error(`Error: ${error}`);
+          const error = "Cannot use --from when the skill argument is a GitHub URL. The URL is used as the plugin source automatically.";
+          if (isJsonMode()) {
+            jsonOutput({ success: false, command: "plugin skills add", error });
             process.exit(1);
           }
-          if (!isJsonMode()) {
-            console.log(`Running initial sync...
-`);
-          }
-          await (isUser ? syncUserWorkspace() : syncWorkspace(workspacePath));
-          matches = await findSkillByName(skill, workspacePath);
-          if (matches.length === 0) {
-            const allSkills = await getAllSkillsFromPlugins(workspacePath);
-            const skillNames = [...new Set(allSkills.map((s) => s.name))].join(", ");
-            const error = `Skill '${skill}' not found in plugin '${from}'.
-
-Available skills: ${skillNames || "none"}
-
-Tip: run \`allagents skills list\` to see all installed skills.`;
+          console.error(`Error: ${error}`);
+          process.exit(1);
+        }
+        from = urlResolved.from;
+        if (urlResolved.parsed && !urlResolved.parsed.subpath) {
+          skill = await resolveSkillNameFromRepo(skill, urlResolved.parsed, urlResolved.skill);
+        } else {
+          skill = urlResolved.skill;
+        }
+      }
+      const matches = await findSkillByName(skill, workspacePath);
+      if (matches.length === 0) {
+        if (from) {
+          const installFromResult = await installSkillFromSource({
+            skill,
+            from,
+            isUser,
+            workspacePath
+          });
+          if (!installFromResult.success) {
             if (isJsonMode()) {
-              jsonOutput({ success: false, command: "plugin skills add", error });
+              jsonOutput({ success: false, command: "plugin skills add", error: installFromResult.error });
               process.exit(1);
             }
-            console.error(`Error: ${error}`);
+            console.error(`Error: ${installFromResult.error}`);
             process.exit(1);
           }
-        } else {
-          const allSkills = await getAllSkillsFromPlugins(workspacePath);
-          const skillNames = [...new Set(allSkills.map((s) => s.name))].join(", ");
-          const error = `Skill '${skill}' not found in any installed plugin.
-
-Available skills: ${skillNames || "none"}`;
           if (isJsonMode()) {
-            jsonOutput({ success: false, command: "plugin skills add", error });
-            process.exit(1);
+            jsonOutput({
+              success: true,
+              command: "plugin skills add",
+              data: {
+                skill,
+                plugin: installFromResult.pluginName,
+                syncResult: installFromResult.syncResult
+              }
+            });
+            return;
           }
-          console.error(`Error: ${error}`);
+          console.log("Sync complete.");
+          return;
+        }
+        const allSkills = await getAllSkillsFromPlugins(workspacePath);
+        const skillNames = [...new Set(allSkills.map((s) => s.name))].join(", ");
+        const error = `Skill '${skill}' not found in any installed plugin.
+
+Available skills: ${skillNames || "none"}`;
+        if (isJsonMode()) {
+          jsonOutput({ success: false, command: "plugin skills add", error });
           process.exit(1);
         }
+        console.error(`Error: ${error}`);
+        process.exit(1);
       }
       let targetSkill = matches[0];
       if (!targetSkill) {
@@ -36485,7 +36694,7 @@ init_format_sync();
 init_workspace_config();
 init_constants();
 init_js_yaml();
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import { existsSync as existsSync20 } from "node:fs";
 import { join as join23 } from "node:path";
 async function runSyncAndPrint(options2) {
@@ -37044,7 +37253,7 @@ var pluginListCmd = import_cmd_ts4.command({
         if (!existsSync20(configPath))
           return;
         try {
-          const content = await readFile13(configPath, "utf-8");
+          const content = await readFile14(configPath, "utf-8");
           const config = load(content);
           if (!config?.plugins || !config?.clients)
             return;
@@ -37480,13 +37689,13 @@ var pluginUpdateCmd = import_cmd_ts4.command({
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
         const { existsSync: existsSync21 } = await import("node:fs");
-        const { readFile: readFile14 } = await import("node:fs/promises");
+        const { readFile: readFile15 } = await import("node:fs/promises");
         const { join: join24 } = await import("node:path");
         const { load: load2 } = await Promise.resolve().then(() => (init_js_yaml(), exports_js_yaml));
         const { CONFIG_DIR: CONFIG_DIR2, WORKSPACE_CONFIG_FILE: WORKSPACE_CONFIG_FILE2 } = await Promise.resolve().then(() => (init_constants(), exports_constants));
         const configPath = join24(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
         if (existsSync21(configPath)) {
-          const content = await readFile14(configPath, "utf-8");
+          const content = await readFile15(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {
             const p = getPluginSource(entry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {
@@ -27,7 +27,8 @@
     "prepare": "bun run build && (test -d .git && bunx prek install -t pre-push || true)",
     "release": "bun run scripts/release.ts",
     "release:next": "bun run scripts/release.ts next",
-    "publish:next": "bun run build && bun publish --tag next"
+    "publish:next": "bun run build && bun publish --tag next",
+    "promote:latest": "bun scripts/tag-channel.ts latest"
   },
   "keywords": [
     "cli",