@ghl-ai/aw 0.1.34-beta.2 → 0.1.34-beta.20

package/apply.mjs

@@ -1,7 +1,7 @@
 // apply.mjs — Apply sync plan (file operations). Zero dependencies.
 
-import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { readFileSync, writeFileSync, mkdirSync, cpSync, existsSync, unlinkSync, rmdirSync, readdirSync } from 'node:fs';
+import { dirname, basename } from 'node:path';
 
 function writeConflictMarkers(filePath, localContent, registryContent) {
   writeFileSync(filePath, [
@@ -51,6 +51,25 @@ export function applyActions(actions, { teamNS } = {}) {
       }
 
       case 'ORPHAN':
+        // File was removed from registry — delete local copy
+        if (existsSync(act.targetPath)) {
+          try { unlinkSync(act.targetPath); } catch { /* best effort */ }
+          // Clean up empty parent dirs, stop at .aw_registry/ boundary
+          let dir = dirname(act.targetPath);
+          while (basename(dir) !== '.aw_registry') {
+            try {
+              const entries = readdirSync(dir);
+              if (entries.length === 0) {
+                rmdirSync(dir);
+                dir = dirname(dir);
+              } else {
+                break;
+              }
+            } catch { break; }
+          }
+        }
+        break;
+
       case 'UNCHANGED':
         break;
     }

package/commands/pull.mjs

@@ -34,7 +34,7 @@ export async function pullCommand(args) {
   const dryRun = args['--dry-run'] === true;
   const verbose = args['-v'] === true || args['--verbose'] === true;
   const silent = args['--silent'] === true || args._silent === true;
-  const renameNamespace = args._renameNamespace || null;
+  let renameNamespace = args._renameNamespace || null;
   const teamNSOverride = args._teamNS || null;
 
   // Silent mode: wrap fmt to suppress all output and exit cleanly on errors
@@ -101,7 +101,13 @@ export async function pullCommand(args) {
   const s = log.spinner();
   s.start('Fetching from registry...');
 
-  const sparsePaths = includeToSparsePaths([pattern]);
+  // When pulling from template with rename, also fetch the actual namespace —
+  // if it exists in the registry, use it directly instead of the template.
+  const pathsToFetch = [pattern];
+  if (renameNamespace && pattern === '[template]') {
+    pathsToFetch.push(renameNamespace);
+  }
+  const sparsePaths = includeToSparsePaths(pathsToFetch);
   let tempDir;
   try {
     tempDir = sparseCheckout(cfg.repo, sparsePaths);
@@ -111,9 +117,22 @@ export async function pullCommand(args) {
   }
 
   try {
-    const registryDirs = [];
     const regBase = join(tempDir, REGISTRY_DIR);
 
+    // Check if actual namespace exists in the registry
+    if (renameNamespace && pattern === '[template]') {
+      const actualNsTopDir = renameNamespace.split('/')[0];
+      const actualNsPath = join(regBase, actualNsTopDir);
+      if (existsSync(actualNsPath)) {
+        const fullNsPath = join(regBase, ...renameNamespace.split('/'));
+        if (existsSync(fullNsPath) && listDirs(fullNsPath).length > 0) {
+          pattern = renameNamespace;
+          renameNamespace = null;  // No rename needed — using actual content
+        }
+      }
+    }
+
+    const registryDirs = [];
     if (existsSync(regBase)) {
       for (const name of listDirs(regBase)) {
         registryDirs.push({ name, path: join(regBase, name) });
@@ -165,7 +184,7 @@ export async function pullCommand(args) {
 
     // Compute plan
     const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], {
-      skipOrphans: true,
+      skipOrphans: false,
     });
     const actions = filterActions(rawActions, pattern);
 
@@ -226,7 +245,7 @@ export async function pullCommand(args) {
 export async function pullAsync(args) {
   const input = args._positional?.[0] || '';
   const workspaceDir = args._workspaceDir;
-  const renameNamespace = args._renameNamespace || null;
+  let renameNamespace = args._renameNamespace || null;
   const teamNSOverride = args._teamNS || null;
 
   const resolved = resolveInput(input, workspaceDir);
@@ -238,13 +257,35 @@ export async function pullAsync(args) {
   const cfg = config.load(workspaceDir);
   if (!cfg) throw new Error('No .sync-config.json found');
 
-  const sparsePaths = includeToSparsePaths([pattern]);
+  // When pulling from template with rename, also fetch the actual namespace —
+  // if it exists in the registry, use it directly instead of the template.
+  const pathsToFetch = [pattern];
+  if (renameNamespace && pattern === '[template]') {
+    pathsToFetch.push(renameNamespace);
+  }
+  const sparsePaths = includeToSparsePaths(pathsToFetch);
   const tempDir = await sparseCheckoutAsync(cfg.repo, sparsePaths);
 
   try {
-    const registryDirs = [];
     const regBase = join(tempDir, REGISTRY_DIR);
 
+    // Check if actual namespace exists in the registry
+    let useActualNamespace = false;
+    if (renameNamespace && pattern === '[template]') {
+      const actualNsTopDir = renameNamespace.split('/')[0];
+      const actualNsPath = join(regBase, actualNsTopDir);
+      if (existsSync(actualNsPath)) {
+        // Verify the full namespace path has content (not just the top-level team dir)
+        const fullNsPath = join(regBase, ...renameNamespace.split('/'));
+        if (existsSync(fullNsPath) && listDirs(fullNsPath).length > 0) {
+          useActualNamespace = true;
+          pattern = renameNamespace;
+          renameNamespace = null;  // No rename needed — using actual content
+        }
+      }
+    }
+
+    const registryDirs = [];
     if (existsSync(regBase)) {
       for (const name of listDirs(regBase)) {
         registryDirs.push({ name, path: join(regBase, name) });
@@ -279,7 +320,7 @@ export async function pullAsync(args) {
       config.addPattern(workspaceDir, pattern);
     }
 
-    const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: true });
+    const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: false });
     const actions = filterActions(rawActions, pattern);
     const conflictCount = applyActions(actions, { teamNS: teamNSOverride || renameNamespace || undefined });
     updateManifest(workspaceDir, actions, cfg.namespace, { fromTemplate: !!renameNamespace });
@@ -377,6 +418,7 @@ function printSummary(actions, verbose, conflictCount) {
     if (counts.ADD > 0) parts.push(chalk.green(`${counts.ADD} new`));
     if (counts.UPDATE > 0) parts.push(chalk.cyan(`${counts.UPDATE} updated`));
     if (counts.CONFLICT > 0) parts.push(chalk.red(`${counts.CONFLICT} conflict`));
+    if (counts.ORPHAN > 0) parts.push(chalk.yellow(`${counts.ORPHAN} removed`));
     const detail = parts.length > 0 ? ` (${parts.join(', ')})` : '';
 
     fmt.logSuccess(`${typeActions.length} ${type} pulled${detail}`);

package/commands/push.mjs

@@ -20,26 +20,56 @@ const PUSHABLE_TYPES = ['agents', 'skills', 'commands', 'evals'];
  * Returns array of { absPath, registryTarget, type, namespace, slug, isDir }.
  */
 function collectBatchFiles(folderAbsPath, workspaceDir) {
-  // Determine the namespace name from path relative to workspaceDir
   const relPath = relative(workspaceDir, folderAbsPath);
-  const nameSegments = relPath.split('/');
-  const baseName = nameSegments[0];
-
-  const entries = walkRegistryTree(folderAbsPath, baseName);
-  return entries.map(entry => {
-    // Build the registry target path for git
-    const registryTarget = entry.type === 'skills'
-      ? `${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,
-      type: entry.type,
-      namespace: entry.namespacePath,
-      slug: entry.slug,
-      isDir: false,
-    };
-  });
+  const segments = relPath.split('/');
+
+  // Detect if user pointed at or inside a type dir (agents/, skills/, etc.).
+  // e.g. "revex/courses/core/evals" → typeFilter=evals, subPathFilter=null
+  // e.g. "revex/courses/core/evals/agents" → typeFilter=evals, subPathFilter="agents"
+  // e.g. "revex/courses/core/evals/agents/architect" → typeFilter=evals, subPathFilter="agents/architect"
+  let typeFilter = null;
+  let subPathFilter = null;
+  let walkDir = folderAbsPath;
+  let walkBaseName = relPath;
+
+  for (let i = 0; i < segments.length; i++) {
+    if (PUSHABLE_TYPES.includes(segments[i])) {
+      // Everything before this segment is the namespace
+      const namespaceParts = segments.slice(0, i);
+      walkBaseName = namespaceParts.join('/');
+      // Walk from the namespace dir (parent of the type dir)
+      walkDir = join(workspaceDir, ...namespaceParts);
+      typeFilter = segments[i];
+      // Anything after the type dir is a sub-path filter (e.g., "agents/architect")
+      if (i + 1 < segments.length) {
+        subPathFilter = segments.slice(i + 1).join('/');
+      }
+      break;
+    }
+  }
+
+  const entries = walkRegistryTree(walkDir, walkBaseName);
+  return entries
+    .filter(entry => {
+      if (typeFilter && entry.type !== typeFilter) return false;
+      // For sub-path filtering (e.g., only evals under "agents" or "agents/architect")
+      if (subPathFilter && !entry.slug.startsWith(subPathFilter)) return false;
+      return true;
+    })
+    .map(entry => {
+      // Skills and evals both have nested slug subdirs (e.g. skills/slug/file, evals/agents/developer/file)
+      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}`;
+      return {
+        absPath: entry.sourcePath,
+        registryTarget,
+        type: entry.type,
+        namespace: entry.namespacePath,
+        slug: entry.slug,
+        isDir: false,
+      };
+    });
 }
 
 /**
@@ -234,23 +264,29 @@ function pushFiles(files, { repo, dryRun, workspaceDir }) {
     const topNamespaces = [...new Set(files.map(f => f.namespace.split('/')[0]))];
     const codeownersPath = join(tempDir, 'CODEOWNERS');
     const newNamespaces = [];
+    const ghUser = getGitHubUser();
     for (const ns of topNamespaces) {
-      if (isNewNamespaceInCodeowners(codeownersPath, ns)) {
+      if (ghUser && isNewNamespaceInCodeowners(codeownersPath, ns)) {
         newNamespaces.push(ns);
-        const ghUser = getGitHubUser();
-        if (ghUser && existsSync(codeownersPath)) {
-          const line = `/${REGISTRY_DIR}/${ns}/ @${ghUser}\n`;
-          appendFileSync(codeownersPath, line);
-        }
+        // Create CODEOWNERS if it doesn't exist yet
+        const line = `/${REGISTRY_DIR}/${ns}/ @${ghUser}\n`;
+        appendFileSync(codeownersPath, line);
       }
     }
-    if (newNamespaces.length > 0) {
+    if (newNamespaces.length > 0 && existsSync(codeownersPath)) {
       execSync('git add CODEOWNERS', { cwd: tempDir, stdio: 'pipe' });
     }
 
     // Stage all registry changes
     execSync(`git add "${REGISTRY_DIR}"`, { cwd: tempDir, stdio: 'pipe' });
 
+    // Check if there are actual changes to commit (files may already exist in remote)
+    const diffStatus = execSync('git diff --cached --name-only', { cwd: tempDir, encoding: 'utf8' }).trim();
+    if (!diffStatus) {
+      s2.stop('No changes');
+      fmt.cancel('Nothing to push — all files already exist in registry with identical content.');
+    }
+
     const prTitle = generatePrTitle(files);
     const commitMsg = files.length === 1
       ? `registry: add ${files[0].type}/${files[0].slug} to ${files[0].namespace}`

package/fmt.mjs

@@ -81,7 +81,7 @@ export function actionLabel(action) {
     case 'UPDATE':    return chalk.bgCyan.black(' UPD ');
     case 'SKIP':      return chalk.bgYellow.black(' SKP ');
     case 'CONFLICT':  return chalk.bgRed.white(' CON ');
-    case 'ORPHAN':    return chalk.bgYellow.black(' ORP ');
+    case 'ORPHAN':    return chalk.bgRed.white(' DEL ');
     case 'UNCHANGED': return chalk.dim(' --- ');
     default:          return chalk.dim(` ${action} `);
   }
@@ -94,6 +94,6 @@ export function countSummary(counts) {
   if (counts.UNCHANGED > 0) parts.push(chalk.dim(`${counts.UNCHANGED} unchanged`));
   if (counts.SKIP > 0)      parts.push(chalk.yellow(`${counts.SKIP} skipped`));
   if (counts.CONFLICT > 0)  parts.push(chalk.red(`${counts.CONFLICT} conflict`));
-  if (counts.ORPHAN > 0)    parts.push(chalk.yellow(`${counts.ORPHAN} orphan`));
+  if (counts.ORPHAN > 0)    parts.push(chalk.red(`${counts.ORPHAN} removed`));
   return parts.join(chalk.dim(' · '));
 }

package/link.mjs

@@ -1,6 +1,6 @@
 // link.mjs — Create symlinks from IDE dirs → .aw_registry/
 
-import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync, symlinkSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readdirSync, unlinkSync, symlinkSync, rmdirSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
@@ -80,11 +80,14 @@ function cleanIdeSymlinks(cwd) {
 }
 
 /**
- * Remove all symlinks in a directory (non-recursive into subdirs,
- * but does walk immediate child directories one level deep).
+ * Remove all symlinks in a directory, then prune empty subdirectories.
+ * Walks depth-first so children are cleaned before parents.
  */
 function cleanSymlinksRecursive(dir) {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+
+  for (const entry of entries) {
     const p = join(dir, entry.name);
     try {
       if (lstatSync(p).isSymbolicLink()) {
@@ -94,6 +97,13 @@ function cleanSymlinksRecursive(dir) {
       }
     } catch { /* best effort */ }
   }
+
+  // Remove directory if now empty (but never remove top-level IDE dirs like .claude/)
+  try {
+    if (readdirSync(dir).length === 0 && !IDE_DIRS.some(d => dir.endsWith(d))) {
+      rmdirSync(dir);
+    }
+  } catch { /* best effort */ }
 }
 
 /**

package/package.json

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

package/plan.mjs

@@ -98,10 +98,24 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
     });
   }
 
-  // Orphans: in manifest but not in plan
+  // Orphans: in manifest but not in plan (scoped to current includePatterns)
   if (manifest.files && !skipOrphans) {
+    // Build a set of all targetFilenames in the plan for exact matching
+    const planTargets = new Set(actions.map(a => a.targetFilename));
+
     for (const [manifestKey, manifestEntry] of Object.entries(manifest.files)) {
-      // manifestKey is now namespace/type/slug.md or namespace/type/slug/relPath
+      // Already handled by the plan — not an orphan
+      if (planTargets.has(manifestKey)) continue;
+
+      // Only consider entries that match the current include patterns.
+      // This prevents one pull (e.g. platform) from orphaning entries
+      // belonging to another namespace (e.g. revex/courses).
+      const manifestRegistryPath = manifestKey.replace(/\.md$/, '');
+      if (includePatterns.length > 0 && !matchesAny(manifestRegistryPath, includePatterns)) {
+        continue;
+      }
+
+      // manifestKey is namespace/type/slug.md or namespace/type/slug/relPath
       const parts = manifestKey.split('/');
       // Find the type segment
       let typeIdx = -1;
@@ -115,22 +129,20 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
       const namespace = parts.slice(0, typeIdx).join('/');
       const type = parts[typeIdx];
       const slug = parts[typeIdx + 1]?.replace(/\.md$/, '');
-      const key = `${namespace}/${type}/${slug}`;
-      if (!plan.has(key)) {
-        actions.push({
-          slug,
-          source: manifestEntry.source || 'unknown',
-          type,
-          action: 'ORPHAN',
-          sourcePath: '',
-          targetPath: join(workspaceDir, manifestKey),
-          targetFilename: manifestKey,
-          isDirectory: false,
-          registryHash: '',
-          namespacePath: parts.slice(0, typeIdx).join('/'),
-          registryPath: '',
-        });
-      }
+
+      actions.push({
+        slug,
+        source: manifestEntry.source || 'unknown',
+        type,
+        action: 'ORPHAN',
+        sourcePath: '',
+        targetPath: join(workspaceDir, manifestKey),
+        targetFilename: manifestKey,
+        isDirectory: false,
+        registryHash: '',
+        namespacePath: namespace,
+        registryPath: '',
+      });
     }
   }