allagents 0.2.1 → 0.2.2

package/dist/index.js

@@ -11059,36 +11059,11 @@ 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, 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 -->
-## 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) {
@@ -13736,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, {
@@ -19751,6 +19752,7 @@ async function validateSkill(skillDir) {
 }
 
 // src/core/transform.ts
+var AGENT_FILES2 = ["AGENTS.md", "CLAUDE.md"];
 async function ensureWorkspaceRules(filePath, rules) {
   const rulesContent = rules ?? WORKSPACE_RULES;
   const startMarker = "<!-- WORKSPACE-RULES:START -->";
@@ -19972,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;
@@ -19982,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) {
@@ -20011,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;
@@ -20021,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) {
@@ -20033,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;
@@ -20544,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)) {
@@ -20576,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,
@@ -20621,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;
@@ -20768,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)) {
@@ -20781,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);
@@ -20800,12 +20839,37 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       workspaceYamlContent = await readFile6(defaultYamlPath, "utf-8");
     }
     await writeFile4(configPath, workspaceYamlContent, "utf-8");
-    const targetAgentsPath = join8(absoluteTarget, "AGENTS.md");
-    await ensureWorkspaceRules(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}`);

package/package.json

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