allagents 0.3.0 → 0.5.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]

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";
@@ -19365,14 +19365,25 @@ function parseGitHubUrl(url) {
     }
     return null;
   }
-  const subpathPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)\/tree\/[^/]+\/(.+)$/;
+  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 branch = subpathMatch[3];
+    const subpath = subpathMatch[4];
+    if (owner && repo && branch && subpath) {
+      return { owner, repo, branch, subpath };
+    }
+  }
+  const branchPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)\/tree\/([^/]+)$/;
+  const branchMatch = normalized.match(branchPattern);
+  if (branchMatch) {
+    const owner = branchMatch[1];
+    const repo = branchMatch[2]?.replace(/\.git$/, "");
+    const branch = branchMatch[3];
+    if (owner && repo && branch) {
+      return { owner, repo, branch };
     }
   }
   const basicPattern = /^https?:\/\/(?:www\.)?github\.com\/([^/]+)\/([^/]+?)(?:\.git)?(?:\/.*)?$/;
@@ -19441,6 +19452,7 @@ function parseFileSource(source, baseDir = process.cwd()) {
         normalized: source,
         owner: parsed.owner,
         repo: parsed.repo,
+        ...parsed.branch && { branch: parsed.branch },
         ...parsed.subpath && { filePath: parsed.subpath }
       };
     }
@@ -21060,6 +21072,130 @@ async function autoRegisterMarketplace(name) {
   };
 }
 
+// src/core/github-fetch.ts
+async function resolveBranchAndSubpath(owner, repo, pathAfterTree) {
+  const parts = pathAfterTree.split("/");
+  for (let i2 = parts.length - 1;i2 >= 1; i2--) {
+    const branch = parts.slice(0, i2).join("/");
+    const subpath = parts.slice(i2).join("/");
+    try {
+      await execa("gh", [
+        "api",
+        `repos/${owner}/${repo}/commits/${encodeURIComponent(branch)}`,
+        "--silent"
+      ]);
+      return { branch, ...subpath && { subpath } };
+    } catch {}
+  }
+  return null;
+}
+async function fetchFileFromGitHub(owner, repo, path3, branch) {
+  try {
+    let endpoint = `repos/${owner}/${repo}/contents/${path3}`;
+    if (branch) {
+      endpoint += `?ref=${encodeURIComponent(branch)}`;
+    }
+    const result = await execa("gh", [
+      "api",
+      endpoint,
+      "--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, branch, 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, branch);
+    if (content) {
+      return {
+        success: true,
+        content
+      };
+    }
+  }
+  if (branch && subpath && !branch.includes("/")) {
+    const resolved = await resolveBranchAndSubpath(owner, repo, `${branch}/${subpath}`);
+    if (resolved && resolved.branch !== branch) {
+      const newBasePath = resolved.subpath || "";
+      const newPathsToTry = newBasePath ? [
+        `${newBasePath}/${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`,
+        `${newBasePath}/${WORKSPACE_CONFIG_FILE}`
+      ] : [
+        `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE}`,
+        WORKSPACE_CONFIG_FILE
+      ];
+      for (const path3 of newPathsToTry) {
+        const content = await fetchFileFromGitHub(owner, repo, path3, resolved.branch);
+        if (content) {
+          return {
+            success: true,
+            content
+          };
+        }
+      }
+    }
+  }
+  return {
+    success: false,
+    error: `No workspace.yaml found in: ${owner}/${repo}${branch ? `@${branch}` : ""}${subpath ? `/${subpath}` : ""}
+  Expected at: ${pathsToTry.join(" or ")}`
+  };
+}
+
 // src/core/workspace.ts
 async function initWorkspace(targetPath = ".", options2 = {}) {
   const absoluteTarget = resolve5(targetPath);
@@ -21079,48 +21215,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}`);
-        }
-      } else {
-        sourceYamlPath = fromPath;
-        const parentDir = dirname5(fromPath);
-        if (parentDir.endsWith(CONFIG_DIR)) {
-          sourceDir = dirname5(parentDir);
-        } else {
-          sourceDir = parentDir;
+      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");
         }
-      }
-      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)) {
@@ -21747,6 +21907,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";
@@ -21756,12 +21919,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";
   }
@@ -21780,7 +21943,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}...
 `);
@@ -21815,9 +21978,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.3.0",
+  "version": "0.5.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",