allagents 0.2.2 → 0.4.0

package/README.md

@@ -60,6 +60,9 @@ bunx allagents
 allagents workspace init my-workspace
 cd my-workspace
 
+# Or initialize from a remote GitHub template
+allagents workspace init my-workspace --from owner/repo/path/to/template
+
 # Add a marketplace (or let auto-registration handle it)
 allagents plugin marketplace add anthropics/claude-plugins-official
 
@@ -71,6 +74,23 @@ allagents workspace plugin add my-plugin@someuser/their-repo
 allagents workspace sync
 ```
 
+### Initialize from Remote Template
+
+Start a new workspace instantly from any GitHub repository containing a `workspace.yaml`:
+
+```bash
+# From GitHub URL
+allagents workspace init ~/my-project --from https://github.com/myorg/templates/tree/main/nodejs
+
+# From shorthand
+allagents workspace init ~/my-project --from myorg/templates/nodejs
+
+# From repo root (looks for .allagents/workspace.yaml or workspace.yaml)
+allagents workspace init ~/my-project --from myorg/templates
+```
+
+This fetches the workspace configuration directly from GitHub - no cloning required.
+
 ## Commands
 
 ### Workspace Commands
@@ -78,6 +98,7 @@ allagents workspace sync
 ```bash
 # Initialize a new workspace from template
 allagents workspace init <path>
+allagents workspace init <path> --from <source>  # From local path or GitHub URL
 
 # Sync all plugins to workspace (non-destructive)
 allagents workspace sync [options]
@@ -130,9 +151,21 @@ allagents plugin validate <path>
 
 ## .allagents/workspace.yaml
 
-The workspace configuration file lives in `.allagents/workspace.yaml` and defines repositories, plugins, and target clients:
+The workspace configuration file lives in `.allagents/workspace.yaml` and defines repositories, plugins, workspace files, and target clients:
 
 ```yaml
+# Workspace file sync (optional) - copy files from a shared source
+workspace:
+  source: ../shared-config              # Default base for relative paths
+  files:
+    - AGENTS.md                         # String shorthand: same source and dest
+    - source: docs/guide.md             # Object form: explicit source
+      dest: GUIDE.md                    # Optional dest (defaults to basename)
+    - dest: CUSTOM.md                   # File-level source override
+      source: ../other-config/CUSTOM.md
+    - dest: AGENTS.md                   # GitHub source
+      source: owner/repo/path/AGENTS.md
+
 repositories:
   - path: ../my-project
     owner: myorg
@@ -154,6 +187,25 @@ clients:
   - cursor
 ```
 
+### Workspace File Sync
+
+The `workspace:` section enables syncing files from external sources to your workspace root. This is useful for sharing agent configurations (AGENTS.md, CLAUDE.md) across multiple projects.
+
+**Key behaviors:**
+- **Source of truth is remote** - Local copies are overwritten on every sync
+- **Deleted files are restored** - If you delete AGENTS.md locally, sync restores it
+- **WORKSPACE-RULES injection** - AGENTS.md and CLAUDE.md automatically get workspace discovery rules injected
+
+**Source resolution:**
+| Format | Example | Resolves to |
+|--------|---------|-------------|
+| String shorthand | `AGENTS.md` | `{workspace.source}/AGENTS.md` |
+| Relative source | `source: docs/guide.md` | `{workspace.source}/docs/guide.md` |
+| File-level override | `source: ../other/file.md` | `../other/file.md` (relative to workspace) |
+| GitHub source | `source: owner/repo/path/file.md` | Fetched from GitHub cache |
+
+**GitHub sources** are fetched fresh on every sync (always pulls latest).
+
 ### Plugin Spec Format
 
 Plugins use the `plugin@marketplace` format:

package/dist/index.js

@@ -11054,9 +11054,9 @@ var {
 } = 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";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname7, join as join12 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/core/workspace.ts
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4, copyFile as copyFile2 } from "node:fs/promises";
@@ -17720,12 +17720,12 @@ var RepositorySchema = exports_external.object({
 var WorkspaceFileSchema = exports_external.union([
   exports_external.string(),
   exports_external.object({
-    source: exports_external.string(),
+    source: exports_external.string().optional(),
     dest: exports_external.string().optional()
   })
 ]);
 var WorkspaceSchema = exports_external.object({
-  source: exports_external.string(),
+  source: exports_external.string().optional(),
   files: exports_external.array(WorkspaceFileSchema)
 });
 var PluginSourceSchema = exports_external.string();
@@ -19431,6 +19431,31 @@ function validatePluginSource(source) {
   }
   return { valid: true };
 }
+function parseFileSource(source, baseDir = process.cwd()) {
+  if (isGitHubUrl(source)) {
+    const parsed = parseGitHubUrl(source);
+    if (parsed) {
+      return {
+        type: "github",
+        original: source,
+        normalized: source,
+        owner: parsed.owner,
+        repo: parsed.repo,
+        ...parsed.subpath && { filePath: parsed.subpath }
+      };
+    }
+    return {
+      type: "local",
+      original: source,
+      normalized: normalizePluginPath(source, baseDir)
+    };
+  }
+  return {
+    type: "local",
+    original: source,
+    normalized: normalizePluginPath(source, baseDir)
+  };
+}
 async function verifyGitHubUrlExists(source) {
   const parsed = parseGitHubUrl(source);
   if (!parsed) {
@@ -19943,8 +19968,56 @@ async function copyPluginToWorkspace(pluginPath, workspacePath, client, options2
   ]);
   return [...commandResults, ...skillResults, ...hookResults, ...agentResults];
 }
+function isExplicitGitHubSource(source) {
+  if (source.startsWith("https://github.com/") || source.startsWith("http://github.com/") || source.startsWith("github.com/") || source.startsWith("gh:")) {
+    return true;
+  }
+  if (!source.startsWith(".") && !source.startsWith("/") && source.includes("/")) {
+    const parts = source.split("/");
+    if (parts.length >= 3) {
+      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
+      if (parts[0] && parts[1] && validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function resolveFileSourcePath(source, defaultSourcePath, githubCache) {
+  if (!isExplicitGitHubSource(source)) {
+    if (source.startsWith("/")) {
+      return { path: source };
+    }
+    if (source.startsWith("../")) {
+      return { path: join4(process.cwd(), source) };
+    }
+    if (defaultSourcePath) {
+      return { path: join4(defaultSourcePath, source) };
+    }
+    return { path: join4(process.cwd(), source) };
+  }
+  const parsed = parseFileSource(source);
+  if (parsed.type === "github" && parsed.owner && parsed.repo && parsed.filePath) {
+    const cacheKey = `${parsed.owner}/${parsed.repo}`;
+    const cachePath = githubCache?.get(cacheKey);
+    if (!cachePath) {
+      return {
+        path: "",
+        error: `GitHub cache not found for ${cacheKey}. Ensure the repo is fetched.`
+      };
+    }
+    return { path: join4(cachePath, parsed.filePath) };
+  }
+  if (parsed.type === "github") {
+    return {
+      path: "",
+      error: `Invalid GitHub file source: ${source}. Must include path to file (e.g., owner/repo/path/to/file.md)`
+    };
+  }
+  return null;
+}
 async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {}) {
-  const { dryRun = false } = options2;
+  const { dryRun = false, githubCache } = options2;
   const results = [];
   const stringPatterns = [];
   const objectEntries = [];
@@ -19953,55 +20026,113 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
     if (typeof file === "string") {
       stringPatterns.push(file);
     } else {
-      objectEntries.push({ source: file.source, dest: file.dest });
+      let dest = file.dest;
+      if (!dest && file.source) {
+        const parts = file.source.split("/");
+        dest = parts[parts.length - 1] || file.source;
+      }
+      if (!dest) {
+        results.push({
+          source: "unknown",
+          destination: join4(workspacePath, "unknown"),
+          action: "failed",
+          error: "File entry must have at least source or dest specified"
+        });
+        continue;
+      }
+      objectEntries.push(file.source ? { source: file.source, dest } : { dest });
     }
   }
   if (stringPatterns.length > 0) {
-    const resolvedFiles = await resolveGlobPatterns(sourcePath, stringPatterns);
-    for (const resolved of resolvedFiles) {
-      const destPath = join4(workspacePath, resolved.relativePath);
-      if (!existsSync3(resolved.sourcePath)) {
-        const wasLiteral = stringPatterns.some((p) => !isGlobPattern(p) && !p.startsWith("!") && p === resolved.relativePath);
-        if (wasLiteral) {
+    if (!sourcePath) {
+      for (const pattern of stringPatterns) {
+        if (!isGlobPattern(pattern) && !pattern.startsWith("!")) {
+          results.push({
+            source: pattern,
+            destination: join4(workspacePath, pattern),
+            action: "failed",
+            error: `Cannot resolve file '${pattern}' - no workspace.source configured and no explicit source provided`
+          });
+        }
+      }
+    } else {
+      const resolvedFiles = await resolveGlobPatterns(sourcePath, stringPatterns);
+      for (const resolved of resolvedFiles) {
+        const destPath = join4(workspacePath, resolved.relativePath);
+        if (!existsSync3(resolved.sourcePath)) {
+          const wasLiteral = stringPatterns.some((p) => !isGlobPattern(p) && !p.startsWith("!") && p === resolved.relativePath);
+          if (wasLiteral) {
+            results.push({
+              source: resolved.sourcePath,
+              destination: destPath,
+              action: "failed",
+              error: `Source file not found: ${resolved.sourcePath}`
+            });
+          }
+          continue;
+        }
+        if (dryRun) {
+          results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
+          if (AGENT_FILES2.includes(resolved.relativePath)) {
+            copiedAgentFiles.push(resolved.relativePath);
+          }
+          continue;
+        }
+        try {
+          await mkdir2(dirname2(destPath), { recursive: true });
+          const content = await readFile3(resolved.sourcePath, "utf-8");
+          await writeFile(destPath, content, "utf-8");
+          results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
+          if (AGENT_FILES2.includes(resolved.relativePath)) {
+            copiedAgentFiles.push(resolved.relativePath);
+          }
+        } catch (error) {
           results.push({
             source: resolved.sourcePath,
             destination: destPath,
             action: "failed",
-            error: `Source file not found: ${resolved.sourcePath}`
+            error: error instanceof Error ? error.message : "Unknown error"
           });
         }
+      }
+    }
+  }
+  for (const entry of objectEntries) {
+    const destPath = join4(workspacePath, entry.dest);
+    let srcPath;
+    if (entry.source) {
+      const resolved = resolveFileSourcePath(entry.source, sourcePath, githubCache);
+      if (!resolved) {
+        results.push({
+          source: entry.source,
+          destination: destPath,
+          action: "failed",
+          error: `Failed to resolve source: ${entry.source}`
+        });
         continue;
       }
-      if (dryRun) {
-        results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
-        if (AGENT_FILES2.includes(resolved.relativePath)) {
-          copiedAgentFiles.push(resolved.relativePath);
-        }
+      if (resolved.error) {
+        results.push({
+          source: entry.source,
+          destination: destPath,
+          action: "failed",
+          error: resolved.error
+        });
         continue;
       }
-      try {
-        await mkdir2(dirname2(destPath), { recursive: true });
-        const content = await readFile3(resolved.sourcePath, "utf-8");
-        await writeFile(destPath, content, "utf-8");
-        results.push({ source: resolved.sourcePath, destination: destPath, action: "copied" });
-        if (AGENT_FILES2.includes(resolved.relativePath)) {
-          copiedAgentFiles.push(resolved.relativePath);
-        }
-      } catch (error) {
+      srcPath = resolved.path;
+    } else {
+      if (!sourcePath) {
         results.push({
-          source: resolved.sourcePath,
+          source: entry.dest,
           destination: destPath,
           action: "failed",
-          error: error instanceof Error ? error.message : "Unknown error"
+          error: `Cannot resolve file '${entry.dest}' - no workspace.source configured and no explicit source provided`
         });
+        continue;
       }
+      srcPath = join4(sourcePath, entry.dest);
     }
-  }
-  for (const entry of objectEntries) {
-    const srcPath = join4(sourcePath, entry.source);
-    const basename = entry.source.split("/").pop() || entry.source;
-    const destFilename = entry.dest ?? basename;
-    const destPath = join4(workspacePath, destFilename);
     if (!existsSync3(srcPath)) {
       results.push({
         source: srcPath,
@@ -20013,8 +20144,8 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
     }
     if (dryRun) {
       results.push({ source: srcPath, destination: destPath, action: "copied" });
-      if (AGENT_FILES2.includes(destFilename)) {
-        copiedAgentFiles.push(destFilename);
+      if (AGENT_FILES2.includes(entry.dest)) {
+        copiedAgentFiles.push(entry.dest);
       }
       continue;
     }
@@ -20023,8 +20154,8 @@ 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 (AGENT_FILES2.includes(destFilename)) {
-        copiedAgentFiles.push(destFilename);
+      if (AGENT_FILES2.includes(entry.dest)) {
+        copiedAgentFiles.push(entry.dest);
       }
     } catch (error) {
       results.push({
@@ -20451,6 +20582,130 @@ async function cleanupEmptyParents(workspacePath, filePath) {
     }
   }
 }
+function isExplicitGitHubSourceForCollection(source) {
+  if (source.startsWith("https://github.com/") || source.startsWith("http://github.com/") || source.startsWith("github.com/") || source.startsWith("gh:")) {
+    return true;
+  }
+  if (!source.startsWith(".") && !source.startsWith("/") && source.includes("/")) {
+    const parts = source.split("/");
+    if (parts.length >= 3) {
+      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
+      if (parts[0] && parts[1] && validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function collectGitHubReposFromFiles(files) {
+  const repos = new Map;
+  for (const file of files) {
+    if (typeof file === "string") {
+      continue;
+    }
+    if (file.source && isExplicitGitHubSourceForCollection(file.source)) {
+      const parsed = parseFileSource(file.source);
+      if (parsed.type === "github" && parsed.owner && parsed.repo) {
+        const key = `${parsed.owner}/${parsed.repo}`;
+        if (!repos.has(key)) {
+          repos.set(key, {
+            owner: parsed.owner,
+            repo: parsed.repo,
+            key
+          });
+        }
+      }
+    }
+  }
+  return Array.from(repos.values());
+}
+async function fetchFileSourceRepos(repos, _force) {
+  const cache = new Map;
+  const errors2 = [];
+  for (const repo of repos) {
+    const result = await fetchPlugin(`${repo.owner}/${repo.repo}`, { force: true });
+    if (result.success) {
+      cache.set(repo.key, result.cachePath);
+    } else {
+      errors2.push(`Failed to fetch ${repo.key}: ${result.error || "Unknown error"}`);
+    }
+  }
+  return { cache, errors: errors2 };
+}
+function isExplicitGitHubSourceForValidation(source) {
+  if (source.startsWith("https://github.com/") || source.startsWith("http://github.com/") || source.startsWith("github.com/") || source.startsWith("gh:")) {
+    return true;
+  }
+  if (!source.startsWith(".") && !source.startsWith("/") && source.includes("/")) {
+    const parts = source.split("/");
+    if (parts.length >= 3) {
+      const validOwnerRepo = /^[a-zA-Z0-9_.-]+$/;
+      if (parts[0] && parts[1] && validOwnerRepo.test(parts[0]) && validOwnerRepo.test(parts[1])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function validateFileSources(files, defaultSourcePath, githubCache) {
+  const errors2 = [];
+  for (const file of files) {
+    if (typeof file === "string") {
+      if (!defaultSourcePath) {
+        errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
+        continue;
+      }
+      const fullPath = join7(defaultSourcePath, file);
+      if (!existsSync6(fullPath)) {
+        errors2.push(`File source not found: ${fullPath}`);
+      }
+      continue;
+    }
+    if (file.source) {
+      if (isExplicitGitHubSourceForValidation(file.source)) {
+        const parsed = parseFileSource(file.source);
+        if (!parsed.owner || !parsed.repo || !parsed.filePath) {
+          errors2.push(`Invalid GitHub file source: ${file.source}. Must include path to file.`);
+          continue;
+        }
+        const cacheKey = `${parsed.owner}/${parsed.repo}`;
+        const cachePath = githubCache.get(cacheKey);
+        if (!cachePath) {
+          errors2.push(`GitHub cache not found for ${cacheKey}`);
+          continue;
+        }
+        const fullPath = join7(cachePath, parsed.filePath);
+        if (!existsSync6(fullPath)) {
+          errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
+        }
+      } else {
+        let fullPath;
+        if (file.source.startsWith("/")) {
+          fullPath = file.source;
+        } else if (file.source.startsWith("../")) {
+          fullPath = resolve4(file.source);
+        } else if (defaultSourcePath) {
+          fullPath = join7(defaultSourcePath, file.source);
+        } else {
+          fullPath = resolve4(file.source);
+        }
+        if (!existsSync6(fullPath)) {
+          errors2.push(`File source not found: ${fullPath}`);
+        }
+      }
+    } else {
+      if (!defaultSourcePath) {
+        errors2.push(`Cannot resolve file '${file.dest}' - no workspace.source configured and no explicit source provided`);
+        continue;
+      }
+      const fullPath = join7(defaultSourcePath, file.dest ?? "");
+      if (!existsSync6(fullPath)) {
+        errors2.push(`File source not found: ${fullPath}`);
+      }
+    }
+  }
+  return errors2;
+}
 function collectSyncedPaths(copyResults, workspacePath, clients) {
   const result = {};
   for (const client of clients) {
@@ -20623,17 +20878,52 @@ ${errors2}`
   }
   const pluginResults = await Promise.all(validatedPlugins.map((validatedPlugin) => copyValidatedPlugin(validatedPlugin, workspacePath, config.clients, dryRun)));
   let workspaceFileResults = [];
-  if (config.workspace && validatedWorkspaceSource) {
-    const sourcePath = validatedWorkspaceSource.resolved;
+  if (config.workspace) {
+    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);
+    if (sourcePath) {
+      for (const agentFile of AGENT_FILES) {
+        const agentPath = join7(sourcePath, agentFile);
+        if (existsSync6(agentPath) && !filesToCopy.includes(agentFile)) {
+          filesToCopy.push(agentFile);
+        }
+      }
+    }
+    const fileSourceRepos = collectGitHubReposFromFiles(filesToCopy);
+    let githubCache = new Map;
+    if (fileSourceRepos.length > 0) {
+      const { cache, errors: errors2 } = await fetchFileSourceRepos(fileSourceRepos, force);
+      if (errors2.length > 0) {
+        return {
+          success: false,
+          pluginResults,
+          totalCopied: 0,
+          totalFailed: errors2.length,
+          totalSkipped: 0,
+          totalGenerated: 0,
+          error: `File source fetch failed (workspace unchanged):
+${errors2.map((e) => `  - ${e}`).join(`
+`)}`
+        };
       }
+      githubCache = cache;
     }
-    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun });
-    if (!dryRun && config.clients.includes("claude")) {
+    const fileValidationErrors = validateFileSources(filesToCopy, sourcePath, githubCache);
+    if (fileValidationErrors.length > 0) {
+      return {
+        success: false,
+        pluginResults,
+        totalCopied: 0,
+        totalFailed: fileValidationErrors.length,
+        totalSkipped: 0,
+        totalGenerated: 0,
+        error: `File source validation failed (workspace unchanged):
+${fileValidationErrors.map((e) => `  - ${e}`).join(`
+`)}`
+      };
+    }
+    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache });
+    if (!dryRun && config.clients.includes("claude") && sourcePath) {
       const claudePath = join7(workspacePath, "CLAUDE.md");
       const agentsPath = join7(workspacePath, "AGENTS.md");
       const claudeExistsInSource = existsSync6(join7(sourcePath, "CLAUDE.md"));
@@ -20770,6 +21060,88 @@ async function autoRegisterMarketplace(name) {
   };
 }
 
+// src/core/github-fetch.ts
+async function fetchFileFromGitHub(owner, repo, path3) {
+  try {
+    const result = await execa("gh", [
+      "api",
+      `repos/${owner}/${repo}/contents/${path3}`,
+      "--jq",
+      ".content"
+    ]);
+    if (result.stdout) {
+      const content = Buffer.from(result.stdout, "base64").toString("utf-8");
+      return content;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function fetchWorkspaceFromGitHub(url) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed) {
+    return {
+      success: false,
+      error: "Invalid GitHub URL format. Expected: https://github.com/owner/repo"
+    };
+  }
+  const { owner, repo, subpath } = parsed;
+  try {
+    await execa("gh", ["--version"]);
+  } catch {
+    return {
+      success: 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 {
+          success: false,
+          error: `Repository not found: ${owner}/${repo}`
+        };
+      }
+      if (errorMessage.includes("auth") || errorMessage.includes("authentication")) {
+        return {
+          success: false,
+          error: "GitHub authentication required. Run: gh auth login"
+        };
+      }
+    }
+    return {
+      success: false,
+      error: `Failed to access repository: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  const basePath = subpath || "";
+  const pathsToTry = basePath ? [
+    `${basePath}/${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`,
+    `${basePath}/${WORKSPACE_CONFIG_FILE}`
+  ] : [
+    `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`,
+    WORKSPACE_CONFIG_FILE
+  ];
+  for (const path3 of pathsToTry) {
+    const content = await fetchFileFromGitHub(owner, repo, path3);
+    if (content) {
+      return {
+        success: true,
+        content
+      };
+    }
+  }
+  return {
+    success: false,
+    error: `No workspace.yaml found in: ${owner}/${repo}${subpath ? `/${subpath}` : ""}
+  Expected at: ${pathsToTry.join(" or ")}`
+  };
+}
+
 // src/core/workspace.ts
 async function initWorkspace(targetPath = ".", options2 = {}) {
   const absoluteTarget = resolve5(targetPath);
@@ -20789,48 +21161,72 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     let workspaceYamlContent;
     let sourceDir;
     if (options2.from) {
-      const fromPath = resolve5(options2.from);
-      if (!existsSync7(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 = join8(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        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}`);
+      if (isGitHubUrl(options2.from)) {
+        const fetchResult = await fetchWorkspaceFromGitHub(options2.from);
+        if (!fetchResult.success || !fetchResult.content) {
+          throw new Error(fetchResult.error || "Failed to fetch workspace from GitHub");
         }
-      } 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) {
+        workspaceYamlContent = fetchResult.content;
         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 });
+            const parsedUrl = parseGitHubUrl(options2.from);
+            if (parsedUrl) {
+              const basePath = parsedUrl.subpath || "";
+              const baseDir = basePath.replace(/\/?\.allagents\/workspace\.yaml$/, "").replace(/\/?workspace\.yaml$/, "");
+              const sourcePath = baseDir ? `${baseDir}/${source}` : source;
+              workspace.source = `https://github.com/${parsedUrl.owner}/${parsedUrl.repo}/tree/main/${sourcePath}`;
+              workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
+            }
           }
         }
+        console.log(`✓ Using workspace.yaml from: ${options2.from}`);
+      } else {
+        const fromPath = resolve5(options2.from);
+        if (!existsSync7(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 = join8(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          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}`);
       }
-      console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
     } else {
       const defaultYamlPath = join8(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
       if (!existsSync7(defaultYamlPath)) {
@@ -21457,6 +21853,9 @@ pluginCommand.command("validate <path>").description("Validate plugin structure
 });
 
 // src/cli/commands/update.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";
 function detectPackageManagerFromPath(scriptPath) {
   if (scriptPath.includes(".bun")) {
     return "bun";
@@ -21466,12 +21865,12 @@ function detectPackageManagerFromPath(scriptPath) {
 function detectPackageManager() {
   return detectPackageManagerFromPath(process.argv[1] ?? "");
 }
-async function getCurrentVersion() {
+function getCurrentVersion() {
   try {
-    const { createRequire: createRequire2 } = await import("node:module");
-    const require2 = createRequire2(import.meta.url);
-    const pkg = require2("../../../package.json");
-    return pkg.version;
+    const __dirname2 = dirname6(fileURLToPath3(import.meta.url));
+    const packageJsonPath = join11(__dirname2, "..", "package.json");
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    return packageJson.version;
   } catch {
     return "unknown";
   }
@@ -21490,7 +21889,7 @@ var updateCommand = new Command("update").description("Update allagents to the l
     } else {
       packageManager = detectPackageManager();
     }
-    const currentVersion = await getCurrentVersion();
+    const currentVersion = getCurrentVersion();
     console.log(`Current version: ${currentVersion}`);
     console.log(`Updating allagents using ${packageManager}...
 `);
@@ -21525,9 +21924,9 @@ Update complete.`);
 });
 
 // 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 __dirname2 = dirname7(fileURLToPath4(import.meta.url));
+var packageJsonPath = join12(__dirname2, "..", "package.json");
+var packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
 var program2 = new Command;
 program2.name("allagents").description("CLI tool for managing multi-repo AI agent workspaces with plugin synchronization").version(packageJson.version);
 program2.addCommand(workspaceCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {
@@ -14,7 +14,7 @@
     "docs:install": "bun install --cwd docs",
     "docs:build": "bun run --cwd docs build",
     "dev": "bun run src/cli/index.ts",
-    "test": "bun test tests/unit/validators tests/unit/utils tests/unit/models && bun test tests/unit/core/marketplace.test.ts tests/unit/core/sync.test.ts tests/unit/core/transform-glob.test.ts && bun test tests/unit/core/plugin.test.ts",
+    "test": "bun test tests/unit/validators tests/unit/utils tests/unit/models && bun test tests/unit/core/marketplace.test.ts tests/unit/core/sync.test.ts tests/unit/core/transform-glob.test.ts tests/unit/core/github-fetch.test.ts && bun test tests/unit/core/plugin.test.ts",
     "test:watch": "bun test --watch",
     "test:coverage": "bun test --coverage",
     "test:integration": "bats tests/integration/*.bats",