allagents 0.8.7 → 0.10.0

package/dist/index.js

@@ -12955,9 +12955,9 @@ function conciseSubcommands(config) {
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
 
 // src/core/workspace.ts
-import { mkdir as mkdir5, readFile as readFile8, writeFile as writeFile4, copyFile as copyFile2 } from "node:fs/promises";
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join9, resolve as resolve6, dirname as dirname5, relative as relative2, sep, isAbsolute as isAbsolute2 } from "node:path";
+import { mkdir as mkdir6, readFile as readFile9, writeFile as writeFile5, copyFile as copyFile2 } from "node:fs/promises";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join10, resolve as resolve6, dirname as dirname5, relative as relative2, sep, isAbsolute as isAbsolute2 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -15608,9 +15608,9 @@ var safeLoadAll = renamed("safeLoadAll", "loadAll");
 var safeDump = renamed("safeDump", "dump");
 
 // src/core/sync.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { rm, unlink, rmdir, copyFile } from "node:fs/promises";
-import { join as join8, resolve as resolve5, dirname as dirname4, relative } from "node:path";
+import { join as join9, resolve as resolve5, dirname as dirname4, relative } from "node:path";
 
 // src/constants.ts
 var CONFIG_DIR = ".allagents";
@@ -21675,6 +21675,46 @@ var CLIENT_MAPPINGS = {
     agentFile: "AGENTS.md"
   }
 };
+var USER_CLIENT_MAPPINGS = {
+  claude: {
+    commandsPath: ".claude/commands/",
+    skillsPath: ".claude/skills/",
+    agentsPath: ".claude/agents/",
+    agentFile: "CLAUDE.md",
+    agentFileFallback: "AGENTS.md",
+    hooksPath: ".claude/hooks/"
+  },
+  copilot: {
+    skillsPath: ".copilot/skills/",
+    agentFile: "AGENTS.md"
+  },
+  codex: {
+    skillsPath: ".codex/skills/",
+    agentFile: "AGENTS.md"
+  },
+  cursor: {
+    skillsPath: ".cursor/skills/",
+    agentFile: "AGENTS.md"
+  },
+  opencode: {
+    skillsPath: ".config/opencode/skills/",
+    agentFile: "AGENTS.md"
+  },
+  gemini: {
+    skillsPath: ".gemini/skills/",
+    agentFile: "GEMINI.md",
+    agentFileFallback: "AGENTS.md"
+  },
+  factory: {
+    skillsPath: ".factory/skills/",
+    agentFile: "AGENTS.md",
+    hooksPath: ".factory/hooks/"
+  },
+  ampcode: {
+    skillsPath: ".config/amp/skills/",
+    agentFile: "AGENTS.md"
+  }
+};
 
 // src/validators/skill.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
@@ -21763,9 +21803,12 @@ async function ensureWorkspaceRules(filePath, rules) {
   }
 }
 var injectWorkspaceRules = ensureWorkspaceRules;
+function getMapping(client, options2) {
+  return options2?.clientMappings?.[client] ?? CLIENT_MAPPINGS[client];
+}
 async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
   const { dryRun = false } = options2;
-  const mapping = CLIENT_MAPPINGS[client];
+  const mapping = getMapping(client, options2);
   const results = [];
   if (!mapping.commandsPath) {
     return results;
@@ -21803,7 +21846,7 @@ async function copyCommands(pluginPath, workspacePath, client, options2 = {}) {
 }
 async function copySkills(pluginPath, workspacePath, client, options2 = {}) {
   const { dryRun = false, skillNameMap } = options2;
-  const mapping = CLIENT_MAPPINGS[client];
+  const mapping = getMapping(client, options2);
   const results = [];
   if (!mapping.skillsPath) {
     return results;
@@ -21872,7 +21915,7 @@ async function collectPluginSkills(pluginPath, pluginSource) {
 }
 async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
   const { dryRun = false } = options2;
-  const mapping = CLIENT_MAPPINGS[client];
+  const mapping = getMapping(client, options2);
   const results = [];
   if (!mapping.hooksPath) {
     return results;
@@ -21902,7 +21945,7 @@ async function copyHooks(pluginPath, workspacePath, client, options2 = {}) {
 }
 async function copyAgents(pluginPath, workspacePath, client, options2 = {}) {
   const { dryRun = false } = options2;
-  const mapping = CLIENT_MAPPINGS[client];
+  const mapping = getMapping(client, options2);
   const results = [];
   if (!mapping.agentsPath) {
     return results;
@@ -22967,6 +23010,117 @@ function getPreviouslySyncedFiles(state, client) {
   return state.files[client] ?? [];
 }
 
+// src/core/user-workspace.ts
+import { readFile as readFile8, writeFile as writeFile4, mkdir as mkdir5 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+var ALL_CLIENTS = [
+  "claude",
+  "copilot",
+  "codex",
+  "cursor",
+  "opencode",
+  "gemini",
+  "factory",
+  "ampcode"
+];
+function getUserWorkspaceConfigPath() {
+  return join8(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
+}
+async function ensureUserWorkspace() {
+  const configPath = getUserWorkspaceConfigPath();
+  if (existsSync7(configPath))
+    return;
+  const defaultConfig = {
+    repositories: [],
+    plugins: [],
+    clients: [...ALL_CLIENTS]
+  };
+  await mkdir5(getAllagentsDir(), { recursive: true });
+  await writeFile4(configPath, dump(defaultConfig, { lineWidth: -1 }), "utf-8");
+}
+async function getUserWorkspaceConfig() {
+  const configPath = getUserWorkspaceConfigPath();
+  if (!existsSync7(configPath))
+    return null;
+  try {
+    const content = await readFile8(configPath, "utf-8");
+    return load(content);
+  } catch {
+    return null;
+  }
+}
+async function addUserPlugin(plugin) {
+  await ensureUserWorkspace();
+  const configPath = getUserWorkspaceConfigPath();
+  if (isPluginSpec(plugin)) {
+    const resolved = await resolvePluginSpecWithAutoRegister(plugin);
+    if (!resolved.success) {
+      return { success: false, error: resolved.error || "Unknown error" };
+    }
+    const normalizedPlugin = resolved.registeredAs ? plugin.replace(/@[^@]+$/, `@${resolved.registeredAs}`) : plugin;
+    return addPluginToUserConfig(normalizedPlugin, configPath, resolved.registeredAs);
+  }
+  if (isGitHubUrl(plugin)) {
+    const validation = validatePluginSource(plugin);
+    if (!validation.valid) {
+      return { success: false, 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 {
+    if (!existsSync7(plugin)) {
+      return {
+        success: false,
+        error: `Plugin not found at ${plugin}`
+      };
+    }
+  }
+  return addPluginToUserConfig(plugin, configPath);
+}
+async function removeUserPlugin(plugin) {
+  await ensureUserWorkspace();
+  const configPath = getUserWorkspaceConfigPath();
+  try {
+    const content = await readFile8(configPath, "utf-8");
+    const config = load(content);
+    let index = config.plugins.indexOf(plugin);
+    if (index === -1) {
+      index = config.plugins.findIndex((p) => p.startsWith(`${plugin}@`) || p === plugin);
+    }
+    if (index === -1) {
+      return { success: false, error: `Plugin not found in user config: ${plugin}` };
+    }
+    config.plugins.splice(index, 1);
+    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function addPluginToUserConfig(plugin, configPath, autoRegistered) {
+  try {
+    const content = await readFile8(configPath, "utf-8");
+    const config = load(content);
+    if (config.plugins.includes(plugin)) {
+      return { success: false, error: `Plugin already exists in user config: ${plugin}` };
+    }
+    config.plugins.push(plugin);
+    await writeFile4(configPath, dump(config, { lineWidth: -1 }), "utf-8");
+    return { success: true, ...autoRegistered && { autoRegistered } };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 // src/core/sync.ts
 async function selectivePurgeWorkspace(workspacePath, state, clients, options2) {
   if (!state) {
@@ -22979,8 +23133,8 @@ async function selectivePurgeWorkspace(workspacePath, state, clients, options2)
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join8(workspacePath, filePath);
-      if (!existsSync7(fullPath)) {
+      const fullPath = join9(workspacePath, filePath);
+      if (!existsSync8(fullPath)) {
         continue;
       }
       try {
@@ -23002,8 +23156,8 @@ async function selectivePurgeWorkspace(workspacePath, state, clients, options2)
 async function cleanupEmptyParents(workspacePath, filePath) {
   let parentPath = dirname4(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join8(workspacePath, parentPath);
-    if (!existsSync7(fullParentPath)) {
+    const fullParentPath = join9(workspacePath, parentPath);
+    if (!existsSync8(fullParentPath)) {
       parentPath = dirname4(parentPath);
       continue;
     }
@@ -23088,8 +23242,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join8(defaultSourcePath, file);
-      if (!existsSync7(fullPath)) {
+      const fullPath = join9(defaultSourcePath, file);
+      if (!existsSync8(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -23107,8 +23261,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join8(cachePath, parsed.filePath);
-        if (!existsSync7(fullPath)) {
+        const fullPath = join9(cachePath, parsed.filePath);
+        if (!existsSync8(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -23118,11 +23272,11 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         } else if (file.source.startsWith("../")) {
           fullPath = resolve5(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join8(defaultSourcePath, file.source);
+          fullPath = join9(defaultSourcePath, file.source);
         } else {
           fullPath = resolve5(file.source);
         }
-        if (!existsSync7(fullPath)) {
+        if (!existsSync8(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -23131,15 +23285,15 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file.dest}' - no workspace.source configured and no explicit source provided`);
         continue;
       }
-      const fullPath = join8(defaultSourcePath, file.dest ?? "");
-      if (!existsSync7(fullPath)) {
+      const fullPath = join9(defaultSourcePath, file.dest ?? "");
+      if (!existsSync8(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
   }
   return errors2;
 }
-function collectSyncedPaths(copyResults, workspacePath, clients) {
+function collectSyncedPaths(copyResults, workspacePath, clients, clientMappings) {
   const result = {};
   for (const client of clients) {
     result[client] = [];
@@ -23150,7 +23304,7 @@ function collectSyncedPaths(copyResults, workspacePath, clients) {
     }
     const relativePath = relative(workspacePath, copyResult.destination).replace(/\\/g, "/");
     for (const client of clients) {
-      const mapping = CLIENT_MAPPINGS[client];
+      const mapping = clientMappings?.[client] ?? CLIENT_MAPPINGS[client];
       if (mapping.skillsPath && relativePath.startsWith(mapping.skillsPath)) {
         const skillName = relativePath.slice(mapping.skillsPath.length);
         if (!skillName.includes("/")) {
@@ -23198,7 +23352,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join8(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join9(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
@@ -23206,7 +23360,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
     };
   }
   const resolvedPath = resolve5(workspacePath, pluginSource);
-  if (!existsSync7(resolvedPath)) {
+  if (!existsSync8(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -23223,10 +23377,10 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
 async function validateAllPlugins(plugins, workspacePath, offline) {
   return Promise.all(plugins.map((plugin) => validatePlugin(plugin, workspacePath, offline)));
 }
-async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap) {
+async function copyValidatedPlugin(validatedPlugin, workspacePath, clients, dryRun, skillNameMap, clientMappings) {
   const copyResults = [];
   for (const client of clients) {
-    const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, { dryRun, ...skillNameMap && { skillNameMap } });
+    const results = await copyPluginToWorkspace(validatedPlugin.resolved, workspacePath, client, { dryRun, ...skillNameMap && { skillNameMap }, ...clientMappings && { clientMappings } });
     copyResults.push(...results);
   }
   const hasFailures = copyResults.some((r) => r.action === "failed");
@@ -23280,9 +23434,9 @@ function buildPluginSkillNameMaps(allSkills) {
 }
 async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   const { offline = false, dryRun = false, workspaceSourceBase } = options2;
-  const configDir = join8(workspacePath, CONFIG_DIR);
-  const configPath = join8(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync7(configPath)) {
+  const configDir = join9(workspacePath, CONFIG_DIR);
+  const configPath = join9(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync8(configPath)) {
     return {
       success: false,
       pluginResults: [],
@@ -23384,8 +23538,8 @@ ${errors2}`
     const filesToCopy = [...config.workspace.files];
     if (sourcePath) {
       for (const agentFile of AGENT_FILES) {
-        const agentPath = join8(sourcePath, agentFile);
-        if (existsSync7(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join9(sourcePath, agentFile);
+        if (existsSync8(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -23425,10 +23579,10 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     }
     workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache });
     if (!dryRun && clients.includes("claude") && sourcePath) {
-      const claudePath = join8(workspacePath, "CLAUDE.md");
-      const agentsPath = join8(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync7(join8(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync7(agentsPath) && !existsSync7(claudePath)) {
+      const claudePath = join9(workspacePath, "CLAUDE.md");
+      const agentsPath = join9(workspacePath, "AGENTS.md");
+      const claudeExistsInSource = existsSync8(join9(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync8(agentsPath) && !existsSync8(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -23494,6 +23648,89 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     purgedPaths
   };
 }
+async function syncUserWorkspace(options2 = {}) {
+  const homeDir = resolve5(process.env.HOME || process.env.USERPROFILE || "~");
+  const config = await getUserWorkspaceConfig();
+  if (!config) {
+    return {
+      success: true,
+      pluginResults: [],
+      totalCopied: 0,
+      totalFailed: 0,
+      totalSkipped: 0,
+      totalGenerated: 0
+    };
+  }
+  const clients = config.clients;
+  const { offline = false, dryRun = false } = options2;
+  const validatedPlugins = await validateAllPlugins(config.plugins, homeDir, offline);
+  const failedValidations = validatedPlugins.filter((v) => !v.success);
+  if (failedValidations.length > 0) {
+    const errors2 = failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
+`);
+    return {
+      success: false,
+      pluginResults: failedValidations.map((v) => ({
+        plugin: v.plugin,
+        resolved: v.resolved,
+        success: false,
+        copyResults: [],
+        ...v.error && { error: v.error }
+      })),
+      totalCopied: 0,
+      totalFailed: failedValidations.length,
+      totalSkipped: 0,
+      totalGenerated: 0,
+      error: `Plugin validation failed:
+${errors2}`
+    };
+  }
+  const previousState = await loadSyncState(homeDir);
+  if (!dryRun) {
+    await selectivePurgeWorkspace(homeDir, previousState, clients);
+  }
+  const allSkills = await collectAllSkills(validatedPlugins);
+  const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
+  const pluginResults = await Promise.all(validatedPlugins.map((vp) => {
+    const skillNameMap = pluginSkillMaps.get(vp.resolved);
+    return copyValidatedPlugin(vp, homeDir, clients, dryRun, skillNameMap, USER_CLIENT_MAPPINGS);
+  }));
+  let totalCopied = 0;
+  let totalFailed = 0;
+  let totalSkipped = 0;
+  let totalGenerated = 0;
+  for (const pluginResult of pluginResults) {
+    for (const copyResult of pluginResult.copyResults) {
+      switch (copyResult.action) {
+        case "copied":
+          totalCopied++;
+          break;
+        case "failed":
+          totalFailed++;
+          break;
+        case "skipped":
+          totalSkipped++;
+          break;
+        case "generated":
+          totalGenerated++;
+          break;
+      }
+    }
+  }
+  if (!dryRun) {
+    const allCopyResults = pluginResults.flatMap((r) => r.copyResults);
+    const syncedFiles = collectSyncedPaths(allCopyResults, homeDir, clients, USER_CLIENT_MAPPINGS);
+    await saveSyncState(homeDir, syncedFiles);
+  }
+  return {
+    success: totalFailed === 0,
+    pluginResults,
+    totalCopied,
+    totalFailed,
+    totalSkipped,
+    totalGenerated
+  };
+}
 
 // src/core/github-fetch.ts
 async function resolveBranchAndSubpath(owner, repo, pathAfterTree) {
@@ -23622,19 +23859,19 @@ async function fetchWorkspaceFromGitHub(url) {
 // src/core/workspace.ts
 async function initWorkspace(targetPath = ".", options2 = {}) {
   const absoluteTarget = resolve6(targetPath);
-  const configDir = join9(absoluteTarget, CONFIG_DIR);
-  const configPath = join9(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync8(configPath)) {
+  const configDir = join10(absoluteTarget, CONFIG_DIR);
+  const configPath = join10(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync9(configPath)) {
     throw new Error(`Workspace already exists: ${absoluteTarget}
   Found existing ${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`);
   }
   const currentFilePath = fileURLToPath2(import.meta.url);
   const currentFileDir = dirname5(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep}dist${sep}`);
-  const defaultTemplatePath = isProduction ? join9(currentFileDir, "templates", "default") : join9(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join10(currentFileDir, "templates", "default") : join10(currentFileDir, "..", "templates", "default");
   try {
-    await mkdir5(absoluteTarget, { recursive: true });
-    await mkdir5(configDir, { recursive: true });
+    await mkdir6(absoluteTarget, { recursive: true });
+    await mkdir6(configDir, { recursive: true });
     let workspaceYamlContent;
     let sourceDir;
     if (options2.from) {
@@ -23663,19 +23900,19 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
         const fromPath = resolve6(options2.from);
-        if (!existsSync8(fromPath)) {
+        if (!existsSync9(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
         const fromStat = await stat2(fromPath);
         let sourceYamlPath;
         if (fromStat.isDirectory()) {
-          const nestedPath = join9(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join9(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync8(nestedPath)) {
+          const nestedPath = join10(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join10(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync9(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync8(rootPath)) {
+          } else if (existsSync9(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -23691,7 +23928,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             sourceDir = parentDir;
           }
         }
-        workspaceYamlContent = await readFile8(sourceYamlPath, "utf-8");
+        workspaceYamlContent = await readFile9(sourceYamlPath, "utf-8");
         if (sourceDir) {
           const parsed2 = load(workspaceYamlContent);
           const workspace = parsed2?.workspace;
@@ -23706,13 +23943,13 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join9(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync8(defaultYamlPath)) {
+      const defaultYamlPath = join10(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync9(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
-      workspaceYamlContent = await readFile8(defaultYamlPath, "utf-8");
+      workspaceYamlContent = await readFile9(defaultYamlPath, "utf-8");
     }
-    await writeFile4(configPath, workspaceYamlContent, "utf-8");
+    await writeFile5(configPath, workspaceYamlContent, "utf-8");
     const copiedAgentFiles = [];
     if (options2.from && isGitHubUrl(options2.from)) {
       const parsedUrl = parseGitHubUrl(options2.from);
@@ -23722,7 +23959,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           const filePath = basePath ? `${basePath}/${agentFile}` : agentFile;
           const content = await fetchFileFromGitHub(parsedUrl.owner, parsedUrl.repo, filePath, parsedUrl.branch);
           if (content) {
-            await writeFile4(join9(absoluteTarget, agentFile), content, "utf-8");
+            await writeFile5(join10(absoluteTarget, agentFile), content, "utf-8");
             copiedAgentFiles.push(agentFile);
           }
         }
@@ -23730,27 +23967,27 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     } else {
       const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
       for (const agentFile of AGENT_FILES) {
-        const sourcePath = join9(effectiveSourceDir, agentFile);
-        if (existsSync8(sourcePath)) {
-          const content = await readFile8(sourcePath, "utf-8");
-          await writeFile4(join9(absoluteTarget, agentFile), content, "utf-8");
+        const sourcePath = join10(effectiveSourceDir, agentFile);
+        if (existsSync9(sourcePath)) {
+          const content = await readFile9(sourcePath, "utf-8");
+          await writeFile5(join10(absoluteTarget, agentFile), content, "utf-8");
           copiedAgentFiles.push(agentFile);
         }
       }
     }
     if (copiedAgentFiles.length === 0) {
-      await ensureWorkspaceRules(join9(absoluteTarget, "AGENTS.md"));
+      await ensureWorkspaceRules(join10(absoluteTarget, "AGENTS.md"));
       copiedAgentFiles.push("AGENTS.md");
     } else {
       for (const agentFile of copiedAgentFiles) {
-        await ensureWorkspaceRules(join9(absoluteTarget, agentFile));
+        await ensureWorkspaceRules(join10(absoluteTarget, agentFile));
       }
     }
     const parsed = load(workspaceYamlContent);
     const clients = parsed?.clients ?? [];
     if (clients.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-      const agentsPath = join9(absoluteTarget, "AGENTS.md");
-      const claudePath = join9(absoluteTarget, "CLAUDE.md");
+      const agentsPath = join10(absoluteTarget, "AGENTS.md");
+      const claudePath = join10(absoluteTarget, "CLAUDE.md");
       await copyFile2(agentsPath, claudePath);
     }
     console.log(`✓ Workspace created at: ${absoluteTarget}`);
@@ -23784,11 +24021,11 @@ Next steps:`);
 }
 
 // src/core/status.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { join as join11 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
-  const configPath = join10(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync9(configPath)) {
+  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync10(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -23827,7 +24064,7 @@ async function getWorkspaceStatus(workspacePath = process.cwd()) {
 function getPluginStatus(parsed) {
   if (parsed.type === "github") {
     const cachePath = parsed.owner && parsed.repo ? getPluginCachePath(parsed.owner, parsed.repo) : "";
-    const available2 = cachePath ? existsSync9(cachePath) : false;
+    const available2 = cachePath ? existsSync10(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -23837,7 +24074,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync9(parsed.normalized);
+  const available = existsSync10(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -23909,13 +24146,15 @@ var syncMeta = {
     "allagents workspace sync",
     "allagents workspace sync --dry-run",
     "allagents workspace sync --client claude",
-    "allagents workspace sync --offline"
+    "allagents workspace sync --offline",
+    "allagents workspace sync --scope user"
   ],
   expectedOutput: "Lists synced files with status per plugin. Exit 0 on success, exit 1 if any files failed.",
   options: [
     { flag: "--offline", type: "boolean", description: "Use cached plugins without fetching latest from remote" },
     { flag: "--dry-run", short: "-n", type: "boolean", description: "Simulate sync without making changes" },
-    { flag: "--client", short: "-c", type: "string", description: "Sync only the specified client (e.g., opencode, claude)" }
+    { flag: "--client", short: "-c", type: "string", description: "Sync only the specified client (e.g., opencode, claude)" },
+    { flag: "--scope", short: "-s", type: "string", description: 'Sync scope: "project" (default) or "user"' }
   ],
   outputSchema: {
     copied: "number",
@@ -24016,10 +24255,12 @@ var syncCmd = import_cmd_ts2.command({
   args: {
     offline: import_cmd_ts2.flag({ long: "offline", description: "Use cached plugins without fetching latest from remote" }),
     dryRun: import_cmd_ts2.flag({ long: "dry-run", short: "n", description: "Simulate sync without making changes" }),
-    client: import_cmd_ts2.option({ type: import_cmd_ts2.optional(import_cmd_ts2.string), long: "client", short: "c", description: "Sync only the specified client (e.g., opencode, claude)" })
+    client: import_cmd_ts2.option({ type: import_cmd_ts2.optional(import_cmd_ts2.string), long: "client", short: "c", description: "Sync only the specified client (e.g., opencode, claude)" }),
+    scope: import_cmd_ts2.option({ type: import_cmd_ts2.optional(import_cmd_ts2.string), long: "scope", short: "s", description: 'Sync scope: "project" (default) or "user"' })
   },
-  handler: async ({ offline, dryRun, client }) => {
+  handler: async ({ offline, dryRun, client, scope }) => {
     try {
+      const isUser = scope === "user";
       if (!isJsonMode()) {
         if (dryRun) {
           console.log(`Dry run mode - no changes will be made
@@ -24029,10 +24270,10 @@ var syncCmd = import_cmd_ts2.command({
           console.log(`Syncing client: ${client}
 `);
         }
-        console.log(`Syncing workspace...
+        console.log(`Syncing ${isUser ? "user" : ""} workspace...
 `);
       }
-      const result = await syncWorkspace(process.cwd(), {
+      const result = isUser ? await syncUserWorkspace({ offline, dryRun }) : await syncWorkspace(process.cwd(), {
         offline,
         dryRun,
         ...client && { clients: [client] }
@@ -24194,12 +24435,12 @@ var workspaceCmd = conciseSubcommands({
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
 
 // src/core/workspace-modify.ts
-import { readFile as readFile9, writeFile as writeFile5 } from "node:fs/promises";
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join11 } from "node:path";
+import { readFile as readFile10, writeFile as writeFile6 } from "node:fs/promises";
+import { existsSync as existsSync11 } from "node:fs";
+import { join as join12 } from "node:path";
 async function addPlugin(plugin, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync10(configPath)) {
+  const configPath = join12(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync11(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -24232,8 +24473,8 @@ async function addPlugin(plugin, workspacePath = process.cwd()) {
       };
     }
   } else {
-    const fullPath = join11(workspacePath, plugin);
-    if (!existsSync10(fullPath) && !existsSync10(plugin)) {
+    const fullPath = join12(workspacePath, plugin);
+    if (!existsSync11(fullPath) && !existsSync11(plugin)) {
       return {
         success: false,
         error: `Plugin not found at ${plugin}`
@@ -24244,7 +24485,7 @@ async function addPlugin(plugin, workspacePath = process.cwd()) {
 }
 async function addPluginToConfig(plugin, configPath, autoRegistered) {
   try {
-    const content = await readFile9(configPath, "utf-8");
+    const content = await readFile10(configPath, "utf-8");
     const config = load(content);
     if (config.plugins.includes(plugin)) {
       return {
@@ -24254,7 +24495,7 @@ async function addPluginToConfig(plugin, configPath, autoRegistered) {
     }
     config.plugins.push(plugin);
     const newContent = dump(config, { lineWidth: -1 });
-    await writeFile5(configPath, newContent, "utf-8");
+    await writeFile6(configPath, newContent, "utf-8");
     return {
       success: true,
       ...autoRegistered && { autoRegistered }
@@ -24267,8 +24508,8 @@ async function addPluginToConfig(plugin, configPath, autoRegistered) {
   }
 }
 async function removePlugin(plugin, workspacePath = process.cwd()) {
-  const configPath = join11(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync10(configPath)) {
+  const configPath = join12(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync11(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -24276,7 +24517,7 @@ async function removePlugin(plugin, workspacePath = process.cwd()) {
     };
   }
   try {
-    const content = await readFile9(configPath, "utf-8");
+    const content = await readFile10(configPath, "utf-8");
     const config = load(content);
     let index = config.plugins.indexOf(plugin);
     if (index === -1 && isPluginSpec(plugin) === false) {
@@ -24290,7 +24531,7 @@ async function removePlugin(plugin, workspacePath = process.cwd()) {
     }
     config.plugins.splice(index, 1);
     const newContent = dump(config, { lineWidth: -1 });
-    await writeFile5(configPath, newContent, "utf-8");
+    await writeFile6(configPath, newContent, "utf-8");
     return { success: true };
   } catch (error) {
     return {
@@ -24406,19 +24647,24 @@ var pluginValidateMeta = {
 };
 var pluginInstallMeta = {
   command: "plugin install",
-  description: "Install plugin to .allagents/workspace.yaml (supports plugin@marketplace, GitHub URL, or local path)",
-  whenToUse: "To add a new plugin to your workspace and immediately sync it",
+  description: "Install plugin to workspace (supports plugin@marketplace, GitHub URL, or local path). Use --scope user for user-level install.",
+  whenToUse: "To add a new plugin to your workspace (or user-level config with --scope user) and immediately sync it",
   examples: [
     "allagents plugin install my-plugin@official",
     "allagents plugin install https://github.com/user/plugin",
-    "allagents plugin install ../local-plugin"
+    "allagents plugin install ../local-plugin",
+    "allagents plugin install my-plugin@official --scope user"
   ],
   expectedOutput: "Confirms the plugin was added, then runs sync. Shows sync results. Exit 0 on success, exit 1 on failure.",
   positionals: [
     { name: "plugin", type: "string", required: true, description: "Plugin identifier (plugin@marketplace, GitHub URL, or local path)" }
   ],
+  options: [
+    { flag: "--scope", short: "-s", type: "string", description: 'Installation scope: "project" (default) or "user"' }
+  ],
   outputSchema: {
     plugin: "string",
+    scope: "string",
     autoRegistered: "string | null",
     syncResult: {
       copied: "number",
@@ -24431,18 +24677,23 @@ var pluginInstallMeta = {
 };
 var pluginUninstallMeta = {
   command: "plugin uninstall",
-  description: "Uninstall plugin from .allagents/workspace.yaml",
-  whenToUse: "To remove a plugin from your workspace config and re-sync",
+  description: "Uninstall plugin from workspace config. Use --scope user for user-level uninstall.",
+  whenToUse: "To remove a plugin from your workspace (or user-level config with --scope user) and re-sync",
   examples: [
     "allagents plugin uninstall my-plugin@official",
-    "allagents plugin uninstall https://github.com/user/plugin"
+    "allagents plugin uninstall https://github.com/user/plugin",
+    "allagents plugin uninstall my-plugin@official --scope user"
   ],
   expectedOutput: "Confirms the plugin was removed, then runs sync to clean up. Exit 0 on success, exit 1 on failure.",
   positionals: [
     { name: "plugin", type: "string", required: true, description: "Plugin identifier to uninstall" }
   ],
+  options: [
+    { flag: "--scope", short: "-s", type: "string", description: 'Installation scope: "project" (default) or "user"' }
+  ],
   outputSchema: {
     plugin: "string",
+    scope: "string",
     syncResult: {
       copied: "number",
       generated: "number",
@@ -24522,6 +24773,56 @@ Sync complete:`);
   }
   return { ok: result.success && result.totalFailed === 0, syncData };
 }
+async function runUserSyncAndPrint() {
+  if (!isJsonMode()) {
+    console.log(`
+Syncing user workspace...
+`);
+  }
+  const result = await syncUserWorkspace();
+  if (!result.success && result.error) {
+    if (!isJsonMode()) {
+      console.error(`Sync error: ${result.error}`);
+    }
+    return { ok: false, syncData: null };
+  }
+  const syncData = buildSyncData2(result);
+  if (!isJsonMode()) {
+    for (const pluginResult of result.pluginResults) {
+      const status = pluginResult.success ? "✓" : "✗";
+      console.log(`${status} Plugin: ${pluginResult.plugin}`);
+      if (pluginResult.error) {
+        console.log(`  Error: ${pluginResult.error}`);
+      }
+      const copied = pluginResult.copyResults.filter((r) => r.action === "copied").length;
+      const generated = pluginResult.copyResults.filter((r) => r.action === "generated").length;
+      const failed = pluginResult.copyResults.filter((r) => r.action === "failed").length;
+      if (copied > 0)
+        console.log(`  Copied: ${copied} files`);
+      if (generated > 0)
+        console.log(`  Generated: ${generated} files`);
+      if (failed > 0) {
+        console.log(`  Failed: ${failed} files`);
+        for (const failedResult of pluginResult.copyResults.filter((r) => r.action === "failed")) {
+          console.log(`    - ${failedResult.destination}: ${failedResult.error}`);
+        }
+      }
+    }
+    console.log(`
+User sync complete:`);
+    console.log(`  Total copied: ${result.totalCopied}`);
+    if (result.totalGenerated > 0) {
+      console.log(`  Total generated: ${result.totalGenerated}`);
+    }
+    if (result.totalFailed > 0) {
+      console.log(`  Total failed: ${result.totalFailed}`);
+    }
+    if (result.totalSkipped > 0) {
+      console.log(`  Total skipped: ${result.totalSkipped}`);
+    }
+  }
+  return { ok: result.success && result.totalFailed === 0, syncData };
+}
 var marketplaceListCmd = import_cmd_ts3.command({
   name: "list",
   description: buildDescription(marketplaceListMeta),
@@ -24855,11 +25156,13 @@ var pluginInstallCmd = import_cmd_ts3.command({
   name: "install",
   description: buildDescription(pluginInstallMeta),
   args: {
-    plugin: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "plugin" })
+    plugin: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "plugin" }),
+    scope: import_cmd_ts3.option({ type: import_cmd_ts3.optional(import_cmd_ts3.string), long: "scope", short: "s", description: 'Installation scope: "project" (default) or "user"' })
   },
-  handler: async ({ plugin }) => {
+  handler: async ({ plugin, scope }) => {
     try {
-      const result = await addPlugin(plugin);
+      const isUser = scope === "user";
+      const result = isUser ? await addUserPlugin(plugin) : await addPlugin(plugin);
       if (!result.success) {
         if (isJsonMode()) {
           jsonOutput({ success: false, command: "plugin install", error: result.error ?? "Unknown error" });
@@ -24869,12 +25172,13 @@ var pluginInstallCmd = import_cmd_ts3.command({
         process.exit(1);
       }
       if (isJsonMode()) {
-        const { ok, syncData } = await runSyncAndPrint();
+        const { ok, syncData } = isUser ? await runUserSyncAndPrint() : await runSyncAndPrint();
         jsonOutput({
           success: ok,
           command: "plugin install",
           data: {
             plugin,
+            scope: isUser ? "user" : "project",
             autoRegistered: result.autoRegistered ?? null,
             syncResult: syncData
           },
@@ -24888,8 +25192,8 @@ var pluginInstallCmd = import_cmd_ts3.command({
       if (result.autoRegistered) {
         console.log(`✓ Auto-registered marketplace: ${result.autoRegistered}`);
       }
-      console.log(`✓ Installed plugin: ${plugin}`);
-      const { ok: syncOk } = await runSyncAndPrint();
+      console.log(`✓ Installed plugin${isUser ? " (user scope)" : ""}: ${plugin}`);
+      const { ok: syncOk } = isUser ? await runUserSyncAndPrint() : await runSyncAndPrint();
       if (!syncOk) {
         process.exit(1);
       }
@@ -24911,11 +25215,13 @@ var pluginUninstallCmd = import_cmd_ts3.command({
   description: buildDescription(pluginUninstallMeta),
   aliases: ["remove"],
   args: {
-    plugin: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "plugin" })
+    plugin: import_cmd_ts3.positional({ type: import_cmd_ts3.string, displayName: "plugin" }),
+    scope: import_cmd_ts3.option({ type: import_cmd_ts3.optional(import_cmd_ts3.string), long: "scope", short: "s", description: 'Installation scope: "project" (default) or "user"' })
   },
-  handler: async ({ plugin }) => {
+  handler: async ({ plugin, scope }) => {
     try {
-      const result = await removePlugin(plugin);
+      const isUser = scope === "user";
+      const result = isUser ? await removeUserPlugin(plugin) : await removePlugin(plugin);
       if (!result.success) {
         if (isJsonMode()) {
           jsonOutput({ success: false, command: "plugin uninstall", error: result.error ?? "Unknown error" });
@@ -24925,12 +25231,13 @@ var pluginUninstallCmd = import_cmd_ts3.command({
         process.exit(1);
       }
       if (isJsonMode()) {
-        const { ok, syncData } = await runSyncAndPrint();
+        const { ok, syncData } = isUser ? await runUserSyncAndPrint() : await runSyncAndPrint();
         jsonOutput({
           success: ok,
           command: "plugin uninstall",
           data: {
             plugin,
+            scope: isUser ? "user" : "project",
             syncResult: syncData
           },
           ...!ok && { error: "Sync completed with failures" }
@@ -24940,8 +25247,8 @@ var pluginUninstallCmd = import_cmd_ts3.command({
         }
         return;
       }
-      console.log(`✓ Uninstalled plugin: ${plugin}`);
-      const { ok: syncOk } = await runSyncAndPrint();
+      console.log(`✓ Uninstalled plugin${isUser ? " (user scope)" : ""}: ${plugin}`);
+      const { ok: syncOk } = isUser ? await runUserSyncAndPrint() : await runSyncAndPrint();
       if (!syncOk) {
         process.exit(1);
       }
@@ -24997,7 +25304,7 @@ var updateMeta = {
 // package.json
 var package_default = {
   name: "allagents",
-  version: "0.8.7",
+  version: "0.10.0",
   description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   type: "module",
   bin: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "0.8.7",
+  "version": "0.10.0",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {