@ghl-ai/aw 0.1.42 → 0.1.43-beta.1

package/commands/init.mjs

@@ -6,6 +6,7 @@
 
 import {
   existsSync,
+  mkdirSync,
   writeFileSync,
   symlinkSync,
   lstatSync,
@@ -90,6 +91,22 @@ function syncHomeAndProjectInstructions(cwd, namespace) {
   }
 }
 
+/**
+ * Create scaffold directories for a new team namespace so the developer
+ * has the standard folder structure ready for agents, skills, commands, and evals.
+ * No-op if the directories already exist.
+ */
+function scaffoldNamespace(awHome, folderName) {
+  const nsDir = join(awHome, REGISTRY_DIR, ...folderName.split('/'));
+  for (const type of ['agents', 'skills', 'commands', 'evals']) {
+    const dir = join(nsDir, type);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, '.gitkeep'), '');
+    }
+  }
+}
+
 // ── Ensure ~/.aw/.git/info/exclude has the whitelist block ─────────────
 //
 // Strategy: only .aw_registry/, .aw_rules/, content/ are tracked — everything
@@ -309,6 +326,7 @@ export async function initCommand(args) {
       const newSparsePaths = [`.aw_registry/${folderName}`, 'content', RULES_SOURCE_DIR];
       addToSparseCheckout(AW_HOME, newSparsePaths);
       config.addPattern(GLOBAL_AW_DIR, folderName);
+      scaffoldNamespace(AW_HOME, folderName);
     } else {
       if (!silent) fmt.logStep('Already initialized — syncing...');
     }
@@ -486,6 +504,7 @@ export async function initCommand(args) {
   const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
   if (folderName) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
+    scaffoldNamespace(AW_HOME, folderName);
   }
   // Parallel batch A: rules sync (HOME + cwd are independent targets)
   syncRulesTargets(HOME);

package/commands/push.mjs

@@ -13,7 +13,7 @@ import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { REGISTRY_REPO, REGISTRY_URL, REGISTRY_BASE_BRANCH, REGISTRY_DIR, AW_CO_AUTHOR } from '../constants.mjs';
 import { resolveInput } from '../paths.mjs';
-import { walkRegistryTree } from '../registry.mjs';
+import { walkRegistryTree, getAllFiles } from '../registry.mjs';
 import {
   detectChanges,
   getStagedFiles,
@@ -236,9 +236,11 @@ function collectBatchFiles(folderAbsPath, registrySubDir) {
       return true;
     })
     .map(entry => {
-      const registryTarget = (entry.type === 'skills' || entry.type === 'evals')
-        ? `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath || entry.filename}`
-        : `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.filename}`;
+      const registryTarget = entry.evalRelPath
+        ? `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.evalRelPath}`
+        : (entry.type === 'skills' || entry.type === 'evals')
+          ? `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath || entry.filename}`
+          : `${REGISTRY_DIR}/${entry.namespacePath}/${entry.type}/${entry.filename}`;
       return {
         absPath: entry.sourcePath,
         registryTarget,
@@ -267,6 +269,36 @@ function parseRegistryPath(relPath) {
   return null;
 }
 
+// ── Colocated eval resolution ─────────────────────────────────────────
+
+/**
+ * Find colocated eval files for a given agent or command.
+ * Evals live at <type>/evals/<slug>/eval-*.md alongside their parent artifact.
+ * Only returns files that have pending changes (present in changedPaths).
+ */
+function resolveColocatedEvals(registrySubDir, namespace, parentType, slug, changedPaths) {
+  if (parentType !== 'agents' && parentType !== 'commands') return [];
+
+  const evalsDir = join(registrySubDir, namespace, parentType, 'evals', slug);
+  if (!existsSync(evalsDir) || !statSync(evalsDir).isDirectory()) return [];
+
+  return getAllFiles(evalsDir)
+    .map(file => {
+      const relFromRegistryBase = file.slice(registrySubDir.length + 1);
+      const registryTarget = `${REGISTRY_DIR}/${relFromRegistryBase}`;
+      return { absPath: file, registryTarget };
+    })
+    .filter(f => changedPaths.has(f.registryTarget))
+    .map(f => ({
+      ...f,
+      type: parentType,
+      namespace,
+      slug,
+      isDir: false,
+      deleted: false,
+    }));
+}
+
 // ── CODEOWNERS helpers ────────────────────────────────────────────────
 
 async function getGitHubUser() {
@@ -727,7 +759,7 @@ export async function pushCommand(args) {
     return;
   }
 
-  await doPush([{
+  const mainFile = {
     absPath,
     registryTarget,
     type: parentDir,
@@ -735,7 +767,11 @@ export async function pushCommand(args) {
     slug,
     isDir,
     deleted: isDeletedFile,
-  }], awHome, dryRun, worktreeFlow);
+  };
+
+  // Include colocated evals for agents/commands (agents/evals/<slug>/*, commands/evals/<slug>/*)
+  const colocatedEvals = resolveColocatedEvals(registrySubDir, namespacePath, parentDir, slug, singleChangedPaths);
+  await doPush([mainFile, ...colocatedEvals], awHome, dryRun, worktreeFlow);
 }
 
 // ── Utilities ─────────────────────────────────────────────────────────

package/ecc.mjs

@@ -12,7 +12,7 @@ import { applyStoredStartupPreferences } from "./startup.mjs";
 
 const AW_ECC_REPO_SSH = "git@github.com:shreyansh-ghl/aw-ecc.git";
 const AW_ECC_REPO_HTTPS = "https://github.com/shreyansh-ghl/aw-ecc.git";
-export const AW_ECC_TAG = "v1.4.41";
+export const AW_ECC_TAG = "v1.4.42";
 
 const MARKETPLACE_NAME = "aw-marketplace";
 const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;

package/link.mjs

@@ -47,6 +47,8 @@ function listDirs(dir) {
  *   platform/frontend/agents/ → { typeDirPath: '.../frontend/agents', segments: ['frontend'] }
  */
 function findNestedTypeDirs(nsDir, typeName) {
+  // Types whose directories may contain colocated evals
+  const COLOCATED_EVAL_PARENTS = new Set(['agents', 'commands']);
   const results = [];
   function walk(dir, segments) {
     if (!existsSync(dir)) return;
@@ -56,6 +58,8 @@ function findNestedTypeDirs(nsDir, typeName) {
         results.push({ typeDirPath: join(dir, entry.name), segments });
       } else if (!ALL_KNOWN_TYPES.has(entry.name)) {
         walk(join(dir, entry.name), [...segments, entry.name]);
+      } else if (typeName === 'evals' && COLOCATED_EVAL_PARENTS.has(entry.name)) {
+        walk(join(dir, entry.name), [...segments, entry.name]);
       }
     }
   }
@@ -187,20 +191,37 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
   // Evals: per-eval-dir symlinks (recursive for nested domain dirs)
   for (const ns of namespaces) {
     for (const { typeDirPath: evalsDir, segments } of findNestedTypeDirs(join(awDir, ns), 'evals')) {
-      for (const subType of listDirs(evalsDir)) {
-        const subDir = join(evalsDir, subType);
-        for (const evalName of listDirs(subDir)) {
-          const flat = [ns, ...segments, subType, evalName].join('-');
+      const isColocated = segments.some(s => s === 'agents' || s === 'commands');
 
+      if (isColocated) {
+        // Colocated evals: agents/evals/<slug>/ — one level of slug dirs
+        for (const evalSlug of listDirs(evalsDir)) {
+          const flat = [ns, ...segments, evalSlug].join('-');
           for (const ide of IDE_DIRS) {
             const linkDir = join(cwd, ide, 'evals');
             mkdirSync(linkDir, { recursive: true });
             const linkPath = join(linkDir, flat);
-            const targetPath = join(subDir, evalName);
+            const targetPath = join(evalsDir, evalSlug);
             const relTarget = relative(linkDir, targetPath);
             try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
           }
         }
+      } else {
+        // Standard evals: evals/<subType>/<slug>/ — two levels of dirs
+        for (const subType of listDirs(evalsDir)) {
+          const subDir = join(evalsDir, subType);
+          for (const evalName of listDirs(subDir)) {
+            const flat = [ns, ...segments, subType, evalName].join('-');
+            for (const ide of IDE_DIRS) {
+              const linkDir = join(cwd, ide, 'evals');
+              mkdirSync(linkDir, { recursive: true });
+              const linkPath = join(linkDir, flat);
+              const targetPath = join(subDir, evalName);
+              const relTarget = relative(linkDir, targetPath);
+              try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
+            }
+          }
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.42",
+  "version": "0.1.43-beta.1",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {

package/registry.mjs

@@ -84,18 +84,37 @@ export function walkRegistryTree(baseDir, baseName) {
             });
           }
         } else {
-          // Agents, commands — flat files
+          // Agents, commands — flat files + colocated evals (same pattern as skills)
           for (const fileEntry of readdirSync(fullPath)) {
             if (fileEntry === '.gitkeep' || fileEntry.startsWith('.')) continue;
             const filePath = join(fullPath, fileEntry);
-            if (!statSync(filePath).isFile()) continue;
-            const slug = fileEntry.replace(/\.md$/, '');
-            const registryPath = `${namespace}/${typeDir}/${slug}`;
-            entries.push({
-              slug, type: typeDir, sourcePath: filePath,
-              isDirectory: false, namespacePath: namespace, registryPath,
-              filename: fileEntry,
-            });
+            if (statSync(filePath).isFile()) {
+              const slug = fileEntry.replace(/\.md$/, '');
+              const registryPath = `${namespace}/${typeDir}/${slug}`;
+              entries.push({
+                slug, type: typeDir, sourcePath: filePath,
+                isDirectory: false, namespacePath: namespace, registryPath,
+                filename: fileEntry,
+              });
+            } else if (fileEntry === 'evals' && statSync(filePath).isDirectory()) {
+              for (const file of getAllFiles(filePath)) {
+                const relFromType = relative(fullPath, file);
+                const relFromEvals = relative(filePath, file);
+                const parts = relFromEvals.split('/');
+                const parentSlug = parts.length > 1 ? parts[0] : '';
+                const filename = parts[parts.length - 1];
+                entries.push({
+                  slug: parentSlug || filename.replace(/\.md$/, ''),
+                  type: typeDir,
+                  sourcePath: file,
+                  isDirectory: false,
+                  namespacePath: namespace,
+                  registryPath: `${namespace}/${typeDir}/${relFromType.replace(/\.md$/, '')}`,
+                  filename,
+                  evalRelPath: relFromType,
+                });
+              }
+            }
           }
         }
       } else if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {