@ghl-ai/aw 0.1.58 → 0.1.60-beta.0

package/commands/push.mjs

@@ -662,6 +662,10 @@ async function publishProjectAwDocs(cwd, home, dryRun, scope = null) {
 // Auto-generate a branch name from the files being pushed.
 function generateBranchName(files, extraPaths = []) {
   const shortId = Date.now().toString(36).slice(-5);
+  const branchSafe = (value) => String(value || '')
+    .replace(/\//g, '-')
+    .replace(/[^A-Za-z0-9._-]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'item';
 
   if (files.length === 0 && extraPaths.length > 0) {
     return `${managedBranchPrefix(extraPaths)}-${shortId}`;
@@ -675,8 +679,8 @@ function generateBranchName(files, extraPaths = []) {
 
   if (files.length === 1) {
     const f = files[0];
-    const nsSlug = f.namespace.replace(/\//g, '-');
-    return `${prefix}/${nsSlug}-${f.type}-${f.slug}-${shortId}`;
+    const nsSlug = branchSafe(f.namespace);
+    return `${prefix}/${nsSlug}-${f.type}-${branchSafe(f.slug)}-${shortId}`;
   }
 
   if (namespaces.length === 1) {
@@ -698,7 +702,7 @@ function singular(type, count) {
 function parseCommitFiles(commits) {
   const result = [];
   for (const c of commits) {
-    const m = c.message.match(/registry:\s+(add|remove|sync)\s+(agents|skills|commands|evals)\/([\w-]+)\s+(?:to|from)\s+([\w/]+)/);
+    const m = c.message.match(/registry:\s+(add|remove|sync)\s+(agents|skills|commands|evals)\/([\w/-]+)\s+(?:to|from)\s+([\w/]+)/);
     if (m) result.push({ verb: m[1], type: m[2], slug: m[3], namespace: m[4] });
   }
   return result;
@@ -860,16 +864,14 @@ function collectBatchFiles(folderAbsPath, registrySubDir) {
   let walkDir = folderAbsPath;
   let walkBaseName = relPath;
 
-  for (let i = 0; i < segments.length; i++) {
-    if (PUSHABLE_TYPES.includes(segments[i])) {
-      const namespaceParts = segments.slice(0, i);
-      walkBaseName = namespaceParts.join('/');
-      walkDir = join(registrySubDir, ...namespaceParts);
-      typeFilter = segments[i];
-      if (i + 1 < segments.length) {
-        subPathFilter = segments.slice(i + 1).join('/');
-      }
-      break;
+  const typeIdx = findPushableTypeIndex(segments);
+  if (typeIdx !== -1) {
+    const namespaceParts = segments.slice(0, typeIdx);
+    walkBaseName = namespaceParts.join('/');
+    walkDir = join(registrySubDir, ...namespaceParts);
+    typeFilter = segments[typeIdx];
+    if (typeIdx + 1 < segments.length) {
+      subPathFilter = segments.slice(typeIdx + 1).join('/');
     }
   }
 
@@ -877,7 +879,10 @@ function collectBatchFiles(folderAbsPath, registrySubDir) {
   return entries
     .filter(entry => {
       if (typeFilter && entry.type !== typeFilter) return false;
-      if (subPathFilter && !entry.slug.startsWith(subPathFilter)) return false;
+      if (subPathFilter) {
+        const prefix = `${subPathFilter}/`;
+        if (entry.slug !== subPathFilter && !entry.slug.startsWith(prefix)) return false;
+      }
       return true;
     })
     .map(entry => {
@@ -900,18 +905,53 @@ function collectBatchFiles(folderAbsPath, registrySubDir) {
 
 // ── Parse type/namespace/slug from a registry-relative path ──────────
 
-function parseRegistryPath(relPath) {
-  const parts = relPath.split('/');
+function findSkillSlugParts(namespaceParts, skillParts, registrySubDir) {
+  if (skillParts.length === 0) return [];
+
+  if (registrySubDir) {
+    for (let i = skillParts.length; i > 0; i--) {
+      const candidate = join(registrySubDir, ...namespaceParts, 'skills', ...skillParts.slice(0, i));
+      if (existsSync(join(candidate, 'SKILL.md'))) return skillParts.slice(0, i);
+    }
+  }
+
+  const skillMdIdx = skillParts.findIndex(part => part === 'SKILL' || part === 'SKILL.md');
+  if (skillMdIdx > 0) return skillParts.slice(0, skillMdIdx);
+
+  return [skillParts[0]];
+}
+
+function findPushableTypeIndex(parts) {
   for (let i = 0; i < parts.length; i++) {
-    if (PUSHABLE_TYPES.includes(parts[i]) && i + 1 < parts.length) {
-      return {
-        type: parts[i],
-        namespace: parts.slice(0, i).join('/'),
-        slug: parts[i + 1].replace(/\.md$/, ''),
-      };
+    if ((parts[i] === 'agents' || parts[i] === 'commands') && parts[i + 1] === 'evals') {
+      return i + 1;
     }
+    if (PUSHABLE_TYPES.includes(parts[i])) return i;
   }
-  return null;
+  return -1;
+}
+
+function parseRegistryPath(relPath, registrySubDir = null) {
+  const parts = relPath.split('/');
+  const typeIdx = findPushableTypeIndex(parts);
+  if (typeIdx === -1 || typeIdx + 1 >= parts.length) return null;
+
+  const namespaceParts = parts.slice(0, typeIdx);
+  if (parts[typeIdx] === 'skills') {
+    const skillParts = parts.slice(typeIdx + 1).map(part => part.replace(/\.md$/, ''));
+    const slugParts = findSkillSlugParts(namespaceParts, skillParts, registrySubDir);
+    return {
+      type: parts[typeIdx],
+      namespace: namespaceParts.join('/'),
+      slug: slugParts.join('/'),
+    };
+  }
+
+  return {
+    type: parts[typeIdx],
+    namespace: namespaceParts.join('/'),
+    slug: parts[typeIdx + 1].replace(/\.md$/, ''),
+  };
 }
 
 // ── Colocated eval resolution ─────────────────────────────────────────
@@ -1198,7 +1238,7 @@ export async function pushCommand(args) {
 
     if (staged.length > 0 || extraStaged.length > 0) {
       const files = staged.map(f => {
-        const meta = parseRegistryPath(f.registryPath);
+        const meta = parseRegistryPath(f.registryPath, registrySubDir);
         const parts = f.registryPath.split('/');
         return {
           absPath: join(awHome, f.path),
@@ -1264,7 +1304,7 @@ export async function pushCommand(args) {
 
     const files = allEntries
       .map(f => {
-        const meta = parseRegistryPath(f.registryPath);
+        const meta = parseRegistryPath(f.registryPath, registrySubDir);
         const parts = f.registryPath.split('/');
         return {
           absPath: join(awHome, f.path),
@@ -1369,7 +1409,7 @@ export async function pushCommand(args) {
     const deletedInFolder = folderChanges.deleted
       .filter(e => !folderPrefix || e.registryPath.startsWith(folderPrefix))
       .map(e => {
-        const meta = parseRegistryPath(e.registryPath);
+        const meta = parseRegistryPath(e.registryPath, registrySubDir);
         const parts = e.registryPath.split('/');
         return {
           absPath: join(awHome, e.path),
@@ -1396,13 +1436,8 @@ export async function pushCommand(args) {
   }
 
   // Single file input
-  const regParts = resolved.registryPath.split('/');
-  let typeIdx = -1;
-  for (let i = regParts.length - 1; i >= 0; i--) {
-    if (PUSHABLE_TYPES.includes(regParts[i])) { typeIdx = i; break; }
-  }
-
-  if (typeIdx === -1 || typeIdx + 1 >= regParts.length) {
+  const meta = parseRegistryPath(resolved.registryPath, registrySubDir);
+  if (!meta?.type || !meta.slug) {
     fmt.cancel([
       `Invalid push path: ${chalk.red(resolved.registryPath)}`,
       '',
@@ -1416,14 +1451,18 @@ export async function pushCommand(args) {
     return;
   }
 
-  const namespaceParts = regParts.slice(0, typeIdx);
-  const parentDir = regParts[typeIdx];
-  const slug = regParts[typeIdx + 1];
-  const namespacePath = namespaceParts.join('/');
+  const parentDir = meta.type;
+  const slug = meta.slug;
+  const namespacePath = meta.namespace;
   const isDir = !isDeletedFile && statSync(absPath).isDirectory();
+  const registryPathWithExt = resolved.registryPath.endsWith('.md')
+    || (!isDeletedFile && absPath && !absPath.endsWith('.md'))
+    || (isDeletedFile && /\.[^/]+$/.test(resolved.registryPath))
+    ? resolved.registryPath
+    : `${resolved.registryPath}.md`;
   const registryTarget = isDir
     ? `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}`
-    : `${REGISTRY_DIR}/${namespacePath}/${parentDir}/${slug}.md`;
+    : `${REGISTRY_DIR}/${registryPathWithExt}`;
 
   // Check if the file actually has changes before trying to commit
   const singleFileChanges = detectChanges(awHome, REGISTRY_DIR);

package/package.json

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

package/registry.mjs

@@ -28,10 +28,33 @@ export function getAllFiles(dirPath) {
   return results;
 }
 
+function findSkillRootDirs(skillsDir) {
+  const results = [];
+
+  function walk(dir, segments) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+      const childDir = join(dir, entry.name);
+      const childSegments = [...segments, entry.name];
+      if (existsSync(join(childDir, 'SKILL.md'))) {
+        results.push({ skillPath: childDir, slug: childSegments.join('/') });
+        continue;
+      }
+
+      walk(childDir, childSegments);
+    }
+  }
+
+  walk(skillsDir, []);
+  return results;
+}
+
 /**
  * Walk a registry directory tree and collect file-level entries.
  * Every file gets its own entry with its full registry path.
- * Skills are NOT atomic — each file inside a skill is registered individually.
+ * Skills are NOT atomic — each file inside a skill root is registered individually.
+ * A skill root is the nearest directory below skills/ that contains SKILL.md.
  */
 export function walkRegistryTree(baseDir, baseName) {
   const entries = [];
@@ -47,13 +70,9 @@ export function walkRegistryTree(baseDir, baseName) {
         const namespace = pathSegments.join('/');
 
         if (typeDir === 'skills') {
-          // Skills are directories — register each file inside individually
-          for (const skillEntry of readdirSync(fullPath, { withFileTypes: true })) {
-            if (skillEntry.name.startsWith('.')) continue;
-            const skillPath = join(fullPath, skillEntry.name);
-            if (!statSync(skillPath).isDirectory()) continue;
-            const slug = skillEntry.name;
-
+          // Skills can be grouped in nested folders. The actual skill root is
+          // the first nested directory that contains SKILL.md.
+          for (const { skillPath, slug } of findSkillRootDirs(fullPath)) {
             for (const file of getAllFiles(skillPath)) {
               const relPath = relative(skillPath, file);
               const relNoExt = relPath.replace(/\.md$/, '');