allagents 0.1.5 → 0.2.2

package/dist/index.js

@@ -1893,12 +1893,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve2, reject) {
+      return new Promise(function(resolve, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve2(is);
+            resolve(is);
           }
         });
       });
@@ -1960,27 +1960,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve2, reject) => {
+    const step = (i2) => new Promise((resolve, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve2(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve2(subStep(p, i2, 0));
+      resolve(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve2, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve, reject) => {
       if (ii === pathExt.length)
-        return resolve2(step(i2 + 1));
+        return resolve(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve2(p + ext);
+            return resolve(p + ext);
         }
-        return resolve2(subStep(p, i2, ii + 1));
+        return resolve(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -11053,39 +11053,17 @@ var {
   Help
 } = import__.default;
 
+// src/cli/index.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname6, join as join11 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
 // src/core/workspace.ts
-import { mkdir as mkdir5, cp as cp2, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, 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 } from "node:path";
+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";
 
-// src/core/sync.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { rm, unlink, rmdir } from "node:fs/promises";
-import { join as join7, resolve as resolve4, dirname as dirname4, relative } from "node:path";
-
-// src/constants.ts
-var CONFIG_DIR = ".allagents";
-var SYNC_STATE_FILE = "sync-state.json";
-var WORKSPACE_CONFIG_FILE = "workspace.yaml";
-var WORKSPACE_CONFIG_PATH = `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`;
-var WORKSPACE_RULES = `
-<!-- WORKSPACE-RULES:START -->
-# Workspace Rules
-
-## Rule: Workspace Discovery
-TRIGGER: Any task
-ACTION: Read \`.allagents/workspace.yaml\` to get repository paths and project domains
-
-## Rule: Correct Repository Paths
-TRIGGER: File operations (read, search, modify)
-ACTION: Use repository paths from \`.allagents/workspace.yaml\`, not assumptions
-<!-- WORKSPACE-RULES:END -->
-`;
-
-// src/utils/workspace-parser.ts
-import { readFile } from "node:fs/promises";
-
 // node_modules/js-yaml/dist/js-yaml.mjs
 /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
 function isNothing(subject) {
@@ -13733,6 +13711,32 @@ var safeLoad = renamed("safeLoad", "load");
 var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
+// src/core/sync.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { rm, unlink, rmdir, copyFile } from "node:fs/promises";
+import { join as join7, resolve as resolve4, dirname as dirname4, relative } from "node:path";
+
+// src/constants.ts
+var CONFIG_DIR = ".allagents";
+var SYNC_STATE_FILE = "sync-state.json";
+var WORKSPACE_CONFIG_FILE = "workspace.yaml";
+var WORKSPACE_CONFIG_PATH = `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`;
+var AGENT_FILES = ["AGENTS.md", "CLAUDE.md"];
+var WORKSPACE_RULES = `
+<!-- WORKSPACE-RULES:START -->
+## Rule: Workspace Discovery
+TRIGGER: Any task
+ACTION: Read \`.allagents/workspace.yaml\` to get repository paths and project domains
+
+## Rule: Correct Repository Paths
+TRIGGER: File operations (read, search, modify)
+ACTION: Use repository paths from \`.allagents/workspace.yaml\`, not assumptions
+<!-- WORKSPACE-RULES:END -->
+`;
+
+// src/utils/workspace-parser.ts
+import { readFile } from "node:fs/promises";
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -17779,122 +17783,6 @@ ${errors2.join(`
 
 // src/utils/plugin-path.ts
 import { resolve, isAbsolute } from "node:path";
-function isGitHubUrl(source) {
-  const explicitPatterns = [
-    /^https?:\/\/github\.com\//,
-    /^https?:\/\/www\.github\.com\//,
-    /^github\.com\//,
-    /^gh:/
-  ];
-  if (explicitPatterns.some((pattern) => pattern.test(source))) {
-    return true;
-  }
-  if (!source.startsWith(".") && !source.startsWith("/") && !source.includes("\\") && !/^[a-zA-Z]:/.test(source) && source.includes("/")) {
-    const parts = source.split("/");
-    if (parts.length >= 2 && parts[0] && parts[1]) {
-      const validOwnerRepo = /^[a-zA-Z0-9_-]+$/;
-      if (validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function parseGitHubUrl(url) {
-  let normalized = url;
-  if (normalized.startsWith("gh:")) {
-    normalized = normalized.replace(/^gh:/, "https://github.com/");
-  }
-  if (normalized.startsWith("github.com/")) {
-    normalized = `https://${normalized}`;
-  }
-  if (!normalized.includes("://") && !normalized.startsWith("github.com")) {
-    const parts = normalized.split("/");
-    if (parts.length >= 2) {
-      const owner = parts[0];
-      const repo = parts[1];
-      const validOwnerRepo = /^[a-zA-Z0-9_-]+$/;
-      if (owner && repo && validOwnerRepo.test(owner) && validOwnerRepo.test(repo)) {
-        if (parts.length > 2) {
-          const subpath = parts.slice(2).join("/");
-          return { owner, repo, subpath };
-        }
-        return { owner, repo };
-      }
-    }
-    return null;
-  }
-  const subpathPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)\/tree\/[^/]+\/(.+)$/;
-  const subpathMatch = normalized.match(subpathPattern);
-  if (subpathMatch) {
-    const owner = subpathMatch[1];
-    const repo = subpathMatch[2]?.replace(/\.git$/, "");
-    const subpath = subpathMatch[3];
-    if (owner && repo && subpath) {
-      return { owner, repo, subpath };
-    }
-  }
-  const basicPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/.*)?$/;
-  const basicMatch = normalized.match(basicPattern);
-  if (basicMatch) {
-    const owner = basicMatch[1];
-    const repo = basicMatch[2]?.replace(/\.git$/, "");
-    if (owner && repo) {
-      return { owner, repo };
-    }
-  }
-  return null;
-}
-function normalizePluginPath(source, baseDir = process.cwd()) {
-  if (isGitHubUrl(source)) {
-    return source;
-  }
-  if (isAbsolute(source)) {
-    return source;
-  }
-  return resolve(baseDir, source);
-}
-function parsePluginSource(source, baseDir = process.cwd()) {
-  if (isGitHubUrl(source)) {
-    const parsed = parseGitHubUrl(source);
-    return {
-      type: "github",
-      original: source,
-      normalized: source,
-      ...parsed?.owner && { owner: parsed.owner },
-      ...parsed?.repo && { repo: parsed.repo }
-    };
-  }
-  return {
-    type: "local",
-    original: source,
-    normalized: normalizePluginPath(source, baseDir)
-  };
-}
-function getPluginCachePath(owner, repo) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
-  return resolve(homeDir, ".allagents", "plugins", "marketplaces", `${owner}-${repo}`);
-}
-function validatePluginSource(source) {
-  if (!source || source.trim() === "") {
-    return { valid: false, error: "Plugin source cannot be empty" };
-  }
-  if (isGitHubUrl(source)) {
-    const parsed = parseGitHubUrl(source);
-    if (!parsed) {
-      return {
-        valid: false,
-        error: "Invalid GitHub URL format. Expected: https://github.com/owner/repo"
-      };
-    }
-  }
-  return { valid: true };
-}
-
-// src/core/plugin.ts
-import { mkdir, readdir, stat } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { dirname, join, resolve as resolve2 } from "node:path";
 
 // node_modules/execa/index.js
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
@@ -18769,7 +18657,7 @@ var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise
     return spawnedPromise;
   }
   let timeoutId;
-  const timeoutPromise = new Promise((resolve2, reject) => {
+  const timeoutPromise = new Promise((resolve, reject) => {
     timeoutId = setTimeout(() => {
       timeoutKill(spawned, killSignal, reject);
     }, timeout);
@@ -19133,9 +19021,9 @@ var mergePromise = (spawned, promise) => {
     Reflect.defineProperty(spawned, property, { ...descriptor, value });
   }
 };
-var getSpawnedPromise = (spawned) => new Promise((resolve2, reject) => {
+var getSpawnedPromise = (spawned) => new Promise((resolve, reject) => {
   spawned.on("exit", (exitCode, signal) => {
-    resolve2({ exitCode, signal });
+    resolve({ exitCode, signal });
   });
   spawned.on("error", (error) => {
     reject(error);
@@ -19431,7 +19319,188 @@ function create$(options2) {
 }
 var $ = create$();
 
+// src/utils/plugin-path.ts
+function isGitHubUrl(source) {
+  const explicitPatterns = [
+    /^https?:\/\/github\.com\//,
+    /^https?:\/\/www\.github\.com\//,
+    /^github\.com\//,
+    /^gh:/
+  ];
+  if (explicitPatterns.some((pattern) => pattern.test(source))) {
+    return true;
+  }
+  if (!source.startsWith(".") && !source.startsWith("/") && !source.includes("\\") && !/^[a-zA-Z]:/.test(source) && source.includes("/")) {
+    const parts = source.split("/");
+    if (parts.length >= 2 && parts[0] && parts[1]) {
+      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
+      if (validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function parseGitHubUrl(url) {
+  let normalized = url;
+  if (normalized.startsWith("gh:")) {
+    normalized = normalized.replace(/^gh:/, "https://github.com/");
+  }
+  if (normalized.startsWith("github.com/")) {
+    normalized = `https://${normalized}`;
+  }
+  if (!normalized.includes("://") && !normalized.startsWith("github.com")) {
+    const parts = normalized.split("/");
+    if (parts.length >= 2) {
+      const owner = parts[0];
+      const repo = parts[1];
+      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
+      if (owner && repo && validOwnerRepo.test(owner) && validOwnerRepo.test(repo)) {
+        if (parts.length > 2) {
+          const subpath = parts.slice(2).join("/");
+          return { owner, repo, subpath };
+        }
+        return { owner, repo };
+      }
+    }
+    return null;
+  }
+  const subpathPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)\/tree\/[^/]+\/(.+)$/;
+  const subpathMatch = normalized.match(subpathPattern);
+  if (subpathMatch) {
+    const owner = subpathMatch[1];
+    const repo = subpathMatch[2]?.replace(/\.git$/, "");
+    const subpath = subpathMatch[3];
+    if (owner && repo && subpath) {
+      return { owner, repo, subpath };
+    }
+  }
+  const basicPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/.*)?$/;
+  const basicMatch = normalized.match(basicPattern);
+  if (basicMatch) {
+    const owner = basicMatch[1];
+    const repo = basicMatch[2]?.replace(/\.git$/, "");
+    if (owner && repo) {
+      return { owner, repo };
+    }
+  }
+  return null;
+}
+function normalizePluginPath(source, baseDir = process.cwd()) {
+  if (isGitHubUrl(source)) {
+    return source;
+  }
+  if (isAbsolute(source)) {
+    return source;
+  }
+  return resolve(baseDir, source);
+}
+function parsePluginSource(source, baseDir = process.cwd()) {
+  if (isGitHubUrl(source)) {
+    const parsed = parseGitHubUrl(source);
+    return {
+      type: "github",
+      original: source,
+      normalized: source,
+      ...parsed?.owner && { owner: parsed.owner },
+      ...parsed?.repo && { repo: parsed.repo }
+    };
+  }
+  return {
+    type: "local",
+    original: source,
+    normalized: normalizePluginPath(source, baseDir)
+  };
+}
+function getPluginCachePath(owner, repo) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
+  return resolve(homeDir, ".allagents", "plugins", "marketplaces", `${owner}-${repo}`);
+}
+function validatePluginSource(source) {
+  if (!source || source.trim() === "") {
+    return { valid: false, error: "Plugin source cannot be empty" };
+  }
+  if (isGitHubUrl(source)) {
+    const parsed = parseGitHubUrl(source);
+    if (!parsed) {
+      return {
+        valid: false,
+        error: "Invalid GitHub URL format. Expected: https://github.com/owner/repo"
+      };
+    }
+  }
+  return { valid: true };
+}
+async function verifyGitHubUrlExists(source) {
+  const parsed = parseGitHubUrl(source);
+  if (!parsed) {
+    return {
+      exists: false,
+      error: "Invalid GitHub URL format. Expected: https://github.com/owner/repo"
+    };
+  }
+  const { owner, repo, subpath } = parsed;
+  try {
+    await execa("gh", ["--version"]);
+  } catch {
+    return {
+      exists: false,
+      error: "gh CLI not installed. Install from: https://cli.github.com"
+    };
+  }
+  try {
+    await execa("gh", ["repo", "view", `${owner}/${repo}`, "--json", "name"]);
+  } catch (error) {
+    if (error instanceof Error) {
+      const errorMessage = error.message.toLowerCase();
+      if (errorMessage.includes("not found") || errorMessage.includes("404") || errorMessage.includes("could not resolve to a repository")) {
+        return {
+          exists: false,
+          error: `Repository not found: ${owner}/${repo}`
+        };
+      }
+      if (errorMessage.includes("auth") || errorMessage.includes("authentication")) {
+        return {
+          exists: false,
+          error: "GitHub authentication required. Run: gh auth login"
+        };
+      }
+    }
+    return {
+      exists: false,
+      error: `Failed to verify repository: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (subpath) {
+    try {
+      await execa("gh", [
+        "api",
+        `repos/${owner}/${repo}/contents/${subpath}`,
+        "--silent"
+      ]);
+    } catch (error) {
+      if (error instanceof Error) {
+        const errorMessage = error.message.toLowerCase();
+        if (errorMessage.includes("not found") || errorMessage.includes("404")) {
+          return {
+            exists: false,
+            error: `Path not found in repository: ${owner}/${repo}/${subpath}`
+          };
+        }
+      }
+      return {
+        exists: false,
+        error: `Failed to verify path: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  return { exists: true };
+}
+
 // src/core/plugin.ts
+import { mkdir, readdir, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve as resolve2 } from "node:path";
 async function fetchPlugin(url, options2 = {}) {
   const { force = false } = options2;
   const validation = validatePluginSource(url);
@@ -19579,7 +19648,6 @@ async function resolveGlobPatterns(sourceRoot, patterns) {
 var CLIENT_MAPPINGS = {
   claude: {
     commandsPath: ".claude/commands/",
-    commandsExt: ".md",
     skillsPath: ".claude/skills/",
     agentsPath: ".claude/agents/",
     agentFile: "CLAUDE.md",
@@ -19587,46 +19655,32 @@ var CLIENT_MAPPINGS = {
     hooksPath: ".claude/hooks/"
   },
   copilot: {
-    commandsPath: ".github/prompts/",
-    commandsExt: ".prompt.md",
     skillsPath: ".github/skills/",
     agentFile: "AGENTS.md"
   },
   codex: {
-    commandsPath: ".codex/prompts/",
-    commandsExt: ".md",
     skillsPath: ".codex/skills/",
     agentFile: "AGENTS.md"
   },
   cursor: {
-    commandsPath: ".cursor/commands/",
-    commandsExt: ".md",
     skillsPath: ".cursor/skills/",
     agentFile: "AGENTS.md"
   },
   opencode: {
-    commandsPath: ".opencode/commands/",
-    commandsExt: ".md",
     skillsPath: ".opencode/skills/",
     agentFile: "AGENTS.md"
   },
   gemini: {
-    commandsPath: ".gemini/commands/",
-    commandsExt: ".md",
     skillsPath: ".gemini/skills/",
     agentFile: "GEMINI.md",
     agentFileFallback: "AGENTS.md"
   },
   factory: {
-    commandsPath: ".factory/commands/",
-    commandsExt: ".md",
     skillsPath: ".factory/skills/",
     agentFile: "AGENTS.md",
     hooksPath: ".factory/hooks/"
   },
   ampcode: {
-    commandsPath: "",
-    commandsExt: ".md",
     skillsPath: "",
     agentFile: "AGENTS.md"
   }
@@ -19698,20 +19752,28 @@ async function validateSkill(skillDir) {
 }
 
 // src/core/transform.ts
-async function injectWorkspaceRules(filePath) {
-  const content = await readFile3(filePath, "utf-8");
+var AGENT_FILES2 = ["AGENTS.md", "CLAUDE.md"];
+async function ensureWorkspaceRules(filePath, rules) {
+  const rulesContent = rules ?? WORKSPACE_RULES;
   const startMarker = "<!-- WORKSPACE-RULES:START -->";
   const endMarker = "<!-- WORKSPACE-RULES:END -->";
+  if (!existsSync3(filePath)) {
+    await writeFile(filePath, `${rulesContent.trim()}
+`, "utf-8");
+    return;
+  }
+  const content = await readFile3(filePath, "utf-8");
   const startIndex = content.indexOf(startMarker);
   const endIndex = content.indexOf(endMarker);
   if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
     const before = content.substring(0, startIndex);
     const after = content.substring(endIndex + endMarker.length);
-    await writeFile(filePath, before + WORKSPACE_RULES.trim() + after, "utf-8");
+    await writeFile(filePath, before + rulesContent.trim() + after, "utf-8");
   } else {
-    await writeFile(filePath, content + WORKSPACE_RULES, "utf-8");
+    await writeFile(filePath, content + rulesContent, "utf-8");
   }
 }
+var injectWorkspaceRules = ensureWorkspaceRules;
 async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   const { dryRun = false } = options2;
   const mapping = CLIENT_MAPPINGS[client];
@@ -19731,11 +19793,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   const mdFiles = files.filter((f) => f.endsWith(".md"));
   const copyPromises = mdFiles.map(async (file) => {
     const sourcePath = join4(sourceDir, file);
-    let destFileName = file;
-    if (mapping.commandsExt === ".prompt.md" && !file.endsWith(".prompt.md")) {
-      destFileName = file.replace(/\.md$/, ".prompt.md");
-    }
-    const destPath = join4(destDir, destFileName);
+    const destPath = join4(destDir, file);
     if (dryRun) {
       return { source: sourcePath, destination: destPath, action: "copied" };
     }
@@ -19916,7 +19974,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
       }
       if (dryRun) {
         results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
-        if (resolved.relativePath === "CLAUDE.md" || resolved.relativePath === "AGENTS.md") {
+        if (AGENT_FILES2.includes(resolved.relativePath)) {
           copiedAgentFiles.push(resolved.relativePath);
         }
         continue;
@@ -19926,7 +19984,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
         const content = await readFile3(resolved.sourcePath, "utf-8");
         await writeFile(destPath, content, "utf-8");
         results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
-        if (resolved.relativePath === "CLAUDE.md" || resolved.relativePath === "AGENTS.md") {
+        if (AGENT_FILES2.includes(resolved.relativePath)) {
           copiedAgentFiles.push(resolved.relativePath);
         }
       } catch (error) {
@@ -19955,7 +20013,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
     }
     if (dryRun) {
       results.push({ source: srcPath, destination: destPath, action: "copied" });
-      if (destFilename === "CLAUDE.md" || destFilename === "AGENTS.md") {
+      if (AGENT_FILES2.includes(destFilename)) {
         copiedAgentFiles.push(destFilename);
       }
       continue;
@@ -19965,7 +20023,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
       const content = await readFile3(srcPath, "utf-8");
       await writeFile(destPath, content, "utf-8");
       results.push({ source: srcPath, destination: destPath, action: "copied" });
-      if (destFilename === "CLAUDE.md" || destFilename === "AGENTS.md") {
+      if (AGENT_FILES2.includes(destFilename)) {
         copiedAgentFiles.push(destFilename);
       }
     } catch (error) {
@@ -19977,19 +20035,19 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
       });
     }
   }
-  const firstAgentFile = copiedAgentFiles[0];
-  if (firstAgentFile && !dryRun) {
-    const targetFile = copiedAgentFiles.includes("AGENTS.md") ? "AGENTS.md" : firstAgentFile;
-    const targetPath = join4(workspacePath, targetFile);
-    try {
-      await injectWorkspaceRules(targetPath);
-    } catch (error) {
-      results.push({
-        source: "WORKSPACE-RULES",
-        destination: targetPath,
-        action: "failed",
-        error: error instanceof Error ? error.message : "Failed to inject WORKSPACE-RULES"
-      });
+  if (!dryRun) {
+    for (const agentFile of copiedAgentFiles) {
+      const targetPath = join4(workspacePath, agentFile);
+      try {
+        await injectWorkspaceRules(targetPath);
+      } catch (error) {
+        results.push({
+          source: "WORKSPACE-RULES",
+          destination: targetPath,
+          action: "failed",
+          error: error instanceof Error ? error.message : "Failed to inject WORKSPACE-RULES"
+        });
+      }
     }
   }
   return results;
@@ -20488,7 +20546,7 @@ async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryR
   };
 }
 async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
-  const { force = false, dryRun = false } = options2;
+  const { force = false, dryRun = false, workspaceSourceBase } = options2;
   const configDir = join7(workspacePath, CONFIG_DIR);
   const configPath = join7(configDir, WORKSPACE_CONFIG_FILE);
   if (!existsSync6(configPath)) {
@@ -20520,7 +20578,8 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   const validatedPlugins = await validateAllPlugins(config.plugins, workspacePath, force);
   let validatedWorkspaceSource = null;
   if (config.workspace?.source) {
-    validatedWorkspaceSource = await validatePlugin(config.workspace.source, workspacePath, force);
+    const sourceBasePath = workspaceSourceBase ?? workspacePath;
+    validatedWorkspaceSource = await validatePlugin(config.workspace.source, sourceBasePath, force);
     if (!validatedWorkspaceSource.success) {
       return {
         success: false,
@@ -20565,7 +20624,23 @@ ${errors2}`
   const pluginResults = await Promise.all(validatedPlugins.map((validatedPlugin) => copyValidatedPlugin(validatedPlugin, workspacePath, config.clients, dryRun)));
   let workspaceFileResults = [];
   if (config.workspace && validatedWorkspaceSource) {
-    workspaceFileResults = await copyWorkspaceFiles(validatedWorkspaceSource.resolved, workspacePath, config.workspace.files, { dryRun });
+    const sourcePath = validatedWorkspaceSource.resolved;
+    const filesToCopy = [...config.workspace.files];
+    for (const agentFile of AGENT_FILES) {
+      const agentPath = join7(sourcePath, agentFile);
+      if (existsSync6(agentPath) && !filesToCopy.includes(agentFile)) {
+        filesToCopy.push(agentFile);
+      }
+    }
+    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun });
+    if (!dryRun && config.clients.includes("claude")) {
+      const claudePath = join7(workspacePath, "CLAUDE.md");
+      const agentsPath = join7(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync6(join7(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync6(agentsPath) && !existsSync6(claudePath)) {
+        await copyFile(agentsPath, claudePath);
+      }
+    }
   }
   let totalCopied = 0;
   let totalFailed = 0;
@@ -20712,6 +20787,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     await mkdir5(absoluteTarget, { recursive: true });
     await mkdir5(configDir, { recursive: true });
     let workspaceYamlContent;
+    let sourceDir;
     if (options2.from) {
       const fromPath = resolve5(options2.from);
       if (!existsSync7(fromPath)) {
@@ -20725,16 +20801,35 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         const rootPath = join8(fromPath, WORKSPACE_CONFIG_FILE);
         if (existsSync7(nestedPath)) {
           sourceYamlPath = nestedPath;
+          sourceDir = fromPath;
         } else if (existsSync7(rootPath)) {
           sourceYamlPath = rootPath;
+          sourceDir = fromPath;
         } else {
           throw new Error(`No workspace.yaml found in: ${fromPath}
   Expected at: ${nestedPath} or ${rootPath}`);
         }
       } else {
         sourceYamlPath = fromPath;
+        const parentDir = dirname5(fromPath);
+        if (parentDir.endsWith(CONFIG_DIR)) {
+          sourceDir = dirname5(parentDir);
+        } else {
+          sourceDir = parentDir;
+        }
       }
       workspaceYamlContent = await readFile6(sourceYamlPath, "utf-8");
+      if (sourceDir) {
+        const parsed2 = load(workspaceYamlContent);
+        const workspace = parsed2?.workspace;
+        if (workspace?.source) {
+          const source = workspace.source;
+          if (!isGitHubUrl(source) && !isAbsolute2(source)) {
+            workspace.source = resolve5(sourceDir, source);
+            workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
+          }
+        }
+      }
       console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
     } else {
       const defaultYamlPath = join8(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
@@ -20744,15 +20839,37 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       workspaceYamlContent = await readFile6(defaultYamlPath, "utf-8");
     }
     await writeFile4(configPath, workspaceYamlContent, "utf-8");
-    const defaultAgentsPath = join8(defaultTemplatePath, "AGENTS.md");
-    const targetAgentsPath = join8(absoluteTarget, "AGENTS.md");
-    if (existsSync7(defaultAgentsPath) && !existsSync7(targetAgentsPath)) {
-      await cp2(defaultAgentsPath, targetAgentsPath);
+    const copiedAgentFiles = [];
+    const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
+    for (const agentFile of AGENT_FILES) {
+      const sourcePath = join8(effectiveSourceDir, agentFile);
+      if (existsSync7(sourcePath)) {
+        const content = await readFile6(sourcePath, "utf-8");
+        await writeFile4(join8(absoluteTarget, agentFile), content, "utf-8");
+        copiedAgentFiles.push(agentFile);
+      }
+    }
+    if (copiedAgentFiles.length === 0) {
+      await ensureWorkspaceRules(join8(absoluteTarget, "AGENTS.md"));
+      copiedAgentFiles.push("AGENTS.md");
+    } else {
+      for (const agentFile of copiedAgentFiles) {
+        await ensureWorkspaceRules(join8(absoluteTarget, agentFile));
+      }
+    }
+    const parsed = load(workspaceYamlContent);
+    const clients = parsed?.clients ?? [];
+    if (clients.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
+      const agentsPath = join8(absoluteTarget, "AGENTS.md");
+      const claudePath = join8(absoluteTarget, "CLAUDE.md");
+      await copyFile2(agentsPath, claudePath);
     }
     console.log(`✓ Workspace created at: ${absoluteTarget}`);
     console.log(`
 Syncing plugins...`);
-    const syncResult = await syncWorkspace(absoluteTarget);
+    const syncResult = await syncWorkspace(absoluteTarget, {
+      ...sourceDir && { workspaceSourceBase: sourceDir }
+    });
     if (!syncResult.success && syncResult.error) {
       if (!syncResult.error.includes("Plugin validation failed")) {
         console.log(`  Note: ${syncResult.error}`);
@@ -20883,6 +21000,13 @@ async function addPlugin(plugin, workspacePath = process.cwd()) {
         error: validation.error || "Invalid GitHub URL"
       };
     }
+    const verifyResult = await verifyGitHubUrlExists(plugin);
+    if (!verifyResult.exists) {
+      return {
+        success: false,
+        error: verifyResult.error || `GitHub URL not found: ${plugin}`
+      };
+    }
   } else {
     const fullPath = join10(workspacePath, plugin);
     if (!existsSync9(fullPath) && !existsSync9(plugin)) {
@@ -21332,9 +21456,81 @@ pluginCommand.command("validate <path>").description("Validate plugin structure
   console.log("(validation not yet implemented)");
 });
 
+// src/cli/commands/update.ts
+function detectPackageManagerFromPath(scriptPath) {
+  if (scriptPath.includes(".bun")) {
+    return "bun";
+  }
+  return "npm";
+}
+function detectPackageManager() {
+  return detectPackageManagerFromPath(process.argv[1] ?? "");
+}
+async function getCurrentVersion() {
+  try {
+    const { createRequire: createRequire2 } = await import("node:module");
+    const require2 = createRequire2(import.meta.url);
+    const pkg = require2("../../../package.json");
+    return pkg.version;
+  } catch {
+    return "unknown";
+  }
+}
+var updateCommand = new Command("update").description("Update allagents to the latest version").option("--npm", "Force update using npm").option("--bun", "Force update using bun").action(async (options2) => {
+  try {
+    let packageManager;
+    if (options2.npm && options2.bun) {
+      console.error("Error: Cannot specify both --npm and --bun");
+      process.exit(1);
+    }
+    if (options2.npm) {
+      packageManager = "npm";
+    } else if (options2.bun) {
+      packageManager = "bun";
+    } else {
+      packageManager = detectPackageManager();
+    }
+    const currentVersion = await getCurrentVersion();
+    console.log(`Current version: ${currentVersion}`);
+    console.log(`Updating allagents using ${packageManager}...
+`);
+    const args = packageManager === "npm" ? ["install", "-g", "allagents@latest"] : ["add", "-g", "allagents@latest"];
+    const result = await execa(packageManager, args, {
+      stdio: "inherit"
+    });
+    if (result.exitCode === 0) {
+      try {
+        const versionResult = await execa("allagents", ["--version"]);
+        const newVersion = versionResult.stdout.trim();
+        console.log(`
+Update complete: ${currentVersion} → ${newVersion}`);
+      } catch {
+        console.log(`
+Update complete.`);
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("ENOENT") || error.message.includes("not found")) {
+        const detected = detectPackageManager();
+        const alternative = detected === "npm" ? "bun" : "npm";
+        console.error(`Error: ${detected} not found. Try using --${alternative} flag.`);
+      } else {
+        console.error(`Error: ${error.message}`);
+      }
+      process.exit(1);
+    }
+    throw error;
+  }
+});
+
 // src/cli/index.ts
+var __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+var packageJsonPath = join11(__dirname2, "..", "package.json");
+var packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
 var program2 = new Command;
-program2.name("allagents").description("CLI tool for managing multi-repo AI agent workspaces with plugin synchronization").version("0.1.0");
+program2.name("allagents").description("CLI tool for managing multi-repo AI agent workspaces with plugin synchronization").version(packageJson.version);
 program2.addCommand(workspaceCommand);
 program2.addCommand(pluginCommand);
+program2.addCommand(updateCommand);
 program2.parse();