@ghl-ai/aw 0.1.34-beta.8 → 0.1.34

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

@@ -1,7 +1,7 @@
 // commands/pull.mjs — Pull content from registry
 
-import { mkdirSync, existsSync, readdirSync, copyFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmdirSync } from 'node:fs';
+import { join, relative } from 'node:path';
 import { homedir } from 'node:os';
 import { execSync } from 'node:child_process';
 import * as config from '../config.mjs';
@@ -184,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);
 
@@ -214,7 +214,7 @@ export async function pullCommand(args) {
     const contentSrc = join(tempDir, DOCS_SOURCE_DIR);
     if (existsSync(contentSrc)) {
       const docsDest = join(workspaceDir, 'platform', 'docs');
-      copyMarkdownTree(contentSrc, docsDest);
+      syncMarkdownTree(contentSrc, docsDest);
     }
 
     // MCP registration (second-class — skip if not available)
@@ -320,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 });
@@ -335,7 +335,7 @@ export async function pullAsync(args) {
     const contentSrc = join(tempDir, DOCS_SOURCE_DIR);
     if (existsSync(contentSrc)) {
       const docsDest = join(workspaceDir, 'platform', 'docs');
-      copyMarkdownTree(contentSrc, docsDest);
+      syncMarkdownTree(contentSrc, docsDest);
     }
 
     return { pattern, actions, conflictCount };
@@ -351,21 +351,59 @@ function listDirs(dir) {
 }
 
 /**
- * Recursively copy only .md files from src to dest, preserving directory structure.
- * Skips images and other non-markdown content.
+ * Collect all .md file paths (relative) in a directory tree.
  */
-function copyMarkdownTree(src, dest) {
-  mkdirSync(dest, { recursive: true });
-  for (const entry of readdirSync(src, { withFileTypes: true })) {
+function collectMarkdownPaths(dir, base) {
+  const paths = new Set();
+  if (!existsSync(dir)) return paths;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (entry.name.startsWith('.')) continue;
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
+    const full = join(dir, entry.name);
     if (entry.isDirectory()) {
-      copyMarkdownTree(srcPath, destPath);
+      for (const p of collectMarkdownPaths(full, base)) paths.add(p);
     } else if (entry.name.endsWith('.md')) {
-      copyFileSync(srcPath, destPath);
+      paths.add(relative(base, full));
+    }
+  }
+  return paths;
+}
+
+/**
+ * Sync .md files from src to dest: copy new/changed, delete removed, prune empty dirs.
+ */
+function syncMarkdownTree(src, dest) {
+  mkdirSync(dest, { recursive: true });
+
+  const remotePaths = collectMarkdownPaths(src, src);
+  const localPaths = collectMarkdownPaths(dest, dest);
+
+  // Copy new and updated files
+  for (const rel of remotePaths) {
+    const srcPath = join(src, rel);
+    const destPath = join(dest, rel);
+    mkdirSync(join(dest, rel, '..'), { recursive: true });
+    copyFileSync(srcPath, destPath);
+  }
+
+  // Delete local files not on remote
+  for (const rel of localPaths) {
+    if (!remotePaths.has(rel)) {
+      const destPath = join(dest, rel);
+      try { unlinkSync(destPath); } catch { /* best effort */ }
+    }
+  }
+
+  // Prune empty directories (bottom-up)
+  function pruneEmpty(dir) {
+    if (!existsSync(dir)) return;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) pruneEmpty(join(dir, entry.name));
     }
+    try {
+      if (readdirSync(dir).length === 0 && dir !== dest) rmdirSync(dir);
+    } catch { /* best effort */ }
   }
+  pruneEmpty(dest);
 }
 
 function registerMcp(namespace) {
@@ -418,6 +456,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

@@ -23,25 +23,39 @@ function collectBatchFiles(folderAbsPath, workspaceDir) {
   const relPath = relative(workspaceDir, folderAbsPath);
   const segments = relPath.split('/');
 
-  // If user pointed at a type dir (e.g. .aw_registry/revex/courses/core/evals),
-  // walk the parent namespace and filter to just that type.
+  // 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
-      walkDir = dirname(folderAbsPath);
-      walkBaseName = segments.slice(0, i).join('/');
+      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 => !typeFilter || entry.type === typeFilter)
+    .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')

package/constants.mjs

@@ -1,7 +1,7 @@
 // constants.mjs — Single source of truth for registry settings.
 
 /** Base branch for PRs and sync checkout */
-export const REGISTRY_BASE_BRANCH = 'feat/aw-push-batch';
+export const REGISTRY_BASE_BRANCH = 'main';
 
 /** Default registry repository */
 export const REGISTRY_REPO = 'GoHighLevel/platform-docs';

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.8",
+  "version": "0.1.34",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {

package/plan.mjs

@@ -98,12 +98,19 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
     });
   }
 
-  // Orphans: in manifest but not in plan
+  // Orphans: in manifest but not in plan.
+  // Scoped to namespaces actually walked — only entries whose namespace was
+  // part of this registry scan can be orphaned. This prevents a "platform" pull
+  // from orphaning "platform/ai" entries (different pull, different sparse checkout).
   if (manifest.files && !skipOrphans) {
+    const planTargets = new Set(actions.map(a => a.targetFilename));
+    const walkedNamespaces = new Set(actions.map(a => a.namespacePath));
+
     for (const [manifestKey, manifestEntry] of Object.entries(manifest.files)) {
-      // manifestKey is now namespace/type/slug.md or namespace/type/slug/relPath
+      if (planTargets.has(manifestKey)) continue;
+
+      // Extract namespace from manifest key
       const parts = manifestKey.split('/');
-      // Find the type segment
       let typeIdx = -1;
       for (let i = 0; i < parts.length; i++) {
         if (['agents', 'skills', 'commands', 'evals'].includes(parts[i])) {
@@ -113,24 +120,26 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
       }
       if (typeIdx === -1) continue;
       const namespace = parts.slice(0, typeIdx).join('/');
+
+      // Only orphan entries whose exact namespace was walked in this scan
+      if (!walkedNamespaces.has(namespace)) continue;
+
       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: '',
+      });
     }
   }