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

package/cli.mjs

@@ -71,8 +71,9 @@ function printHelp() {
   const sec = (title) => `\n  ${chalk.bold.underline(title)}`;
   const help = [
     sec('Setup'),
-    cmd('aw init --namespace <team>', 'Initialize workspace (required)'),
+    cmd('aw init --namespace <team/sub-team>', 'Initialize workspace (required)'),
     `  ${chalk.dim('Teams: revex, mobile, commerce, leadgen, crm, marketplace, ai')}`,
+    `  ${chalk.dim('Example: aw init --namespace revex/courses')}`,
 
     sec('Download'),
     cmd('aw pull', 'Re-pull all synced paths (like git pull)'),

package/commands/init.mjs

@@ -146,26 +146,47 @@ export async function initCommand(args) {
     fmt.cancel([
       `Missing required ${chalk.bold('--namespace')} flag`,
       '',
-      `  ${chalk.dim('Usage:')}  aw init --namespace <team>`,
+      `  ${chalk.dim('Usage:')}  aw init --namespace <team/sub-team>`,
       `  ${chalk.dim('Teams:')}  ${list}`,
       '',
-      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce')}`,
+      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce/payments')}`,
     ].join('\n'));
   }
 
-  if (namespace && !ALLOWED_NAMESPACES.includes(namespace)) {
+  // Parse team/sub-team
+  const nsParts = namespace ? namespace.split('/') : [];
+  const team = nsParts[0] || null;
+  const subTeam = nsParts[1] || null;
+  const teamNS = subTeam ? `${team}-${subTeam}` : team;          // for $TEAM_NS replacement
+  const folderName = subTeam ? `${team}/${subTeam}` : team;       // for .aw_registry/ path
+
+  if (team && !ALLOWED_NAMESPACES.includes(team)) {
     const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
     fmt.cancel([
-      `Unknown namespace ${chalk.red(namespace)}`,
+      `Unknown team ${chalk.red(team)}`,
       '',
       `  ${chalk.dim('Allowed:')} ${list}`,
       '',
-      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce')}`,
+      `  ${chalk.dim('Example:')} ${chalk.bold('aw init --namespace commerce/payments')}`,
+    ].join('\n'));
+  }
+
+  if (team && !subTeam) {
+    fmt.cancel([
+      `Missing sub-team in ${chalk.red(namespace)}`,
+      '',
+      `  ${chalk.dim('Format:')}  --namespace <team>/<sub-team>`,
+      '',
+      `  ${chalk.dim('Example:')} ${chalk.bold(`aw init --namespace ${team}/courses`)}`,
     ].join('\n'));
   }
 
-  if (namespace && !/^[a-z][a-z0-9-]{1,38}[a-z0-9]$/.test(namespace)) {
-    fmt.cancel(`Invalid namespace '${namespace}' — must match: ^[a-z][a-z0-9-]{1,38}[a-z0-9]$`);
+  const SLUG_RE = /^[a-z][a-z0-9-]{1,38}[a-z0-9]$/;
+  if (team && !SLUG_RE.test(team)) {
+    fmt.cancel(`Invalid team '${team}' — must match: ${SLUG_RE}`);
+  }
+  if (subTeam && !SLUG_RE.test(subTeam)) {
+    fmt.cancel(`Invalid sub-team '${subTeam}' — must match: ${SLUG_RE}`);
   }
 
   const hasConfig = config.exists(GLOBAL_AW_DIR);
@@ -176,21 +197,40 @@ export async function initCommand(args) {
   // ── Fast path: already initialized → just pull + link ─────────────────
 
   if (isExisting) {
-    if (!silent) fmt.logStep('Already initialized — syncing...');
+    const cfg = config.load(GLOBAL_AW_DIR);
+
+    // Add new sub-team if not already tracked
+    const isNewSubTeam = folderName && cfg && !cfg.include.includes(folderName);
+    if (isNewSubTeam) {
+      if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
+      await pullAsync({
+        ...args,
+        _positional: ['[template]'],
+        _renameNamespace: folderName,
+        _teamNS: teamNS,
+        _workspaceDir: GLOBAL_AW_DIR,
+        _skipIntegrate: true,
+      });
+      config.addPattern(GLOBAL_AW_DIR, folderName);
+    } else {
+      if (!silent) fmt.logStep('Already initialized — syncing...');
+    }
 
     // Pull latest (parallel)
-    // cfg.include has the renamed namespace (e.g. 'revex'), but the repo
+    // cfg.include has the renamed namespace (e.g. 'revex/courses'), but the repo
     // only has 'registry/[template]/' — remap non-platform entries back.
-    const cfg = config.load(GLOBAL_AW_DIR);
-    if (cfg && cfg.include.length > 0) {
-      const pullJobs = cfg.include.map(p => {
+    const freshCfg = config.load(GLOBAL_AW_DIR);
+    if (freshCfg && freshCfg.include.length > 0) {
+      const pullJobs = freshCfg.include.map(p => {
         const isTeamNs = p !== 'platform';
+        const derivedTeamNS = isTeamNs ? p.replace(/\//g, '-') : undefined;
         return pullAsync({
           ...args,
           _positional: [isTeamNs ? '[template]' : p],
           _workspaceDir: GLOBAL_AW_DIR,
           _skipIntegrate: true,
           _renameNamespace: isTeamNs ? p : undefined,
+          _teamNS: derivedTeamNS,
         });
       });
       await Promise.all(pullJobs);
@@ -199,9 +239,9 @@ export async function initCommand(args) {
     // Re-link IDE dirs (idempotent)
     linkWorkspace(HOME);
     generateCommands(HOME);
-    copyInstructions(HOME, null, namespace) || [];
+    copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
-    setupMcp(HOME, namespace) || [];
+    setupMcp(HOME, freshCfg?.namespace || team) || [];
 
     // Link current project if needed
     if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
@@ -213,7 +253,7 @@ export async function initCommand(args) {
 
     if (!silent) {
       fmt.outro([
-        'Sync complete',
+        isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Sync complete',
         '',
         `  ${chalk.green('✓')} Registry updated`,
         `  ${chalk.green('✓')} IDE integration refreshed`,
@@ -235,26 +275,26 @@ export async function initCommand(args) {
   // Step 1: Create global source of truth
   mkdirSync(GLOBAL_AW_DIR, { recursive: true });
 
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace, user });
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
 
   fmt.note([
     `${chalk.dim('source:')}     ~/.aw_registry/`,
-    namespace ? `${chalk.dim('namespace:')}  ${cfg.namespace}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
+    folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
     user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config created');
 
   // Step 2: Pull registry content (parallel)
   const s = fmt.spinner();
-  const pullTargets = namespace ? `platform + ${namespace}` : 'platform';
+  const pullTargets = folderName ? `platform + ${folderName}` : 'platform';
   s.start(`Pulling ${pullTargets}...`);
 
   const pullJobs = [
     pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
   ];
-  if (namespace) {
+  if (folderName) {
     pullJobs.push(
-      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
+      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: folderName, _teamNS: teamNS, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
     );
   }
 
@@ -275,9 +315,9 @@ export async function initCommand(args) {
   fmt.logStep('Linking IDE symlinks...');
   linkWorkspace(HOME);
   generateCommands(HOME);
-  const instructionFiles = copyInstructions(HOME, null, namespace) || [];
+  const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
-  const mcpFiles = setupMcp(HOME, namespace) || [];
+  const mcpFiles = setupMcp(HOME, team) || [];
   const gitTemplateInstalled = installGitTemplate();
   installIdeTasks();
 

package/commands/pull.mjs

@@ -17,7 +17,14 @@ import { resolveInput } from '../paths.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
 
-export function pullCommand(args) {
+// Filter out top-level platform CLI meta-commands (drop, pull, push, etc.)
+// but keep domain-specific commands (platform/design/commands/, platform/infra/commands/).
+function filterActions(actions, pattern) {
+  if (pattern !== 'platform') return actions;
+  return actions.filter(a => !(a.type === 'commands' && a.namespacePath === 'platform'));
+}
+
+export async function pullCommand(args) {
   const input = args._positional?.[0] || '';
   const cwd = process.cwd();
   const GLOBAL_AW_DIR = join(homedir(), '.aw_registry');
@@ -27,6 +34,7 @@ export function pullCommand(args) {
   const verbose = args['-v'] === true || args['--verbose'] === true;
   const silent = args['--silent'] === true || args._silent === true;
   const renameNamespace = args._renameNamespace || null;
+  const teamNSOverride = args._teamNS || null;
 
   // Silent mode: wrap fmt to suppress all output and exit cleanly on errors
   const log = {
@@ -41,7 +49,7 @@ export function pullCommand(args) {
     spinner: silent ? () => ({ start: () => {}, stop: () => {} }) : fmt.spinner,
   };
 
-  // No args = re-pull everything in sync config
+  // No args = re-pull everything in sync config (parallel)
   if (!input) {
     const cfg = config.load(workspaceDir);
     if (!cfg) log.cancel('No .sync-config.json found. Run: aw init');
@@ -49,9 +57,19 @@ export function pullCommand(args) {
       log.cancel('Nothing to pull. Add paths first:\n\n  aw pull <path>');
     }
     log.logInfo(`Pulling ${chalk.cyan(cfg.include.length)} synced path${cfg.include.length > 1 ? 's' : ''}...`);
-    for (const p of cfg.include) {
-      pullCommand({ ...args, _positional: [p], _skipIntegrate: true });
-    }
+    const pullJobs = cfg.include.map(p => {
+      const isTeamNs = p !== 'platform';
+      const derivedTeamNS = isTeamNs ? p.replace(/\//g, '-') : undefined;
+      return pullAsync({
+        ...args,
+        _positional: [isTeamNs ? '[template]' : p],
+        _workspaceDir: workspaceDir,
+        _skipIntegrate: true,
+        _renameNamespace: isTeamNs ? p : undefined,
+        _teamNS: derivedTeamNS,
+      });
+    });
+    await Promise.all(pullJobs);
     // Post-pull IDE integration (once after all paths pulled)
     linkWorkspace(cwd);
     generateCommands(cwd);
@@ -145,9 +163,10 @@ export function pullCommand(args) {
     }
 
     // Compute plan
-    const { actions } = computePlan(registryDirs, workspaceDir, [pattern], {
+    const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], {
       skipOrphans: true,
     });
+    const actions = filterActions(rawActions, pattern);
 
     if (dryRun) {
       printDryRun(actions, verbose);
@@ -157,7 +176,7 @@ export function pullCommand(args) {
     // Apply
     const s2 = log.spinner();
     s2.start('Applying changes...');
-    const conflictCount = applyActions(actions, { teamNS: renameNamespace || undefined });
+    const conflictCount = applyActions(actions, { teamNS: teamNSOverride || renameNamespace || undefined });
     updateManifest(workspaceDir, actions, cfg.namespace);
     s2.stop('Changes applied');
 
@@ -200,6 +219,7 @@ export async function pullAsync(args) {
   const input = args._positional?.[0] || '';
   const workspaceDir = args._workspaceDir;
   const renameNamespace = args._renameNamespace || null;
+  const teamNSOverride = args._teamNS || null;
 
   const resolved = resolveInput(input, workspaceDir);
   let pattern = resolved.registryPath;
@@ -251,8 +271,9 @@ export async function pullAsync(args) {
       config.addPattern(workspaceDir, pattern);
     }
 
-    const { actions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: true });
-    const conflictCount = applyActions(actions, { teamNS: renameNamespace || undefined });
+    const { actions: rawActions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: true });
+    const actions = filterActions(rawActions, pattern);
+    const conflictCount = applyActions(actions, { teamNS: teamNSOverride || renameNamespace || undefined });
     updateManifest(workspaceDir, actions, cfg.namespace);
 
     const ROOT_REGISTRY_FILES = ['AW-PROTOCOL.md'];

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 = 'chore/restructure';
+export const REGISTRY_BASE_BRANCH = 'master';
 
 /** Default registry repository */
 export const REGISTRY_REPO = 'GoHighLevel/ghl-agentic-workspace';

package/integrate.mjs

@@ -3,24 +3,11 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import * as fmt from './fmt.mjs';
-
-// AW CLI commands to generate
-const AW_COMMANDS = [
-  { name: 'pull',   description: 'Pull agents & skills from registry',           hint: '<path>' },
-  { name: 'push',   description: 'Push local changes to registry',               hint: '<path>' },
-  { name: 'status', description: 'Show workspace sync status',                   hint: '' },
-  { name: 'drop',   description: 'Stop syncing a path',                          hint: '<path>' },
-  { name: 'search', description: 'Search local and remote registry',             hint: '<query>' },
-  { name: 'nuke',   description: 'Remove entire .aw_registry/',            hint: '' },
-];
+import * as config from './config.mjs';
 
 /**
- * Generate /aw:* commands directly into namespace commands/ dirs.
- * Writes CLI commands + agent invoke commands alongside hand-written commands.
- * link.mjs symlinks everything from commands/ → .claude/commands/aw/ for discovery.
- *
- * A .generated-manifest.json tracks which files were generated so they can be
- * cleaned on rebuild without needing filename prefixes.
+ * Count hand-written commands already present in the registry.
+ * No CLI stub generation — all commands come from the registry itself.
  */
 export function generateCommands(cwd) {
   const awDir = join(cwd, '.aw_registry');
@@ -29,56 +16,15 @@ export function generateCommands(cwd) {
   const oldGenDir = join(awDir, '.generated-commands');
   if (existsSync(oldGenDir)) rmSync(oldGenDir, { recursive: true, force: true });
 
+  // Count hand-written commands across all namespaces for reporting
   let count = 0;
-  const namespaces = listNamespaceDirs(awDir);
-
+  const namespaces = getTeamNamespaces(awDir);
   for (const ns of namespaces) {
-    const commandsDir = join(awDir, ns, 'commands');
-    mkdirSync(commandsDir, { recursive: true });
-
-    // 1. CLI commands
-    for (const cmd of AW_COMMANDS) {
-      const fileName = `${cmd.name}.md`;
-      // Skip if a hand-written command with same name exists
-      if (existsSync(join(commandsDir, fileName))) continue;
-
-      const content = [
-        '---',
-        `name: aw:${cmd.name}`,
-        `description: ${cmd.description}`,
-        cmd.hint ? `argument-hint: "${cmd.hint}"` : null,
-        '---',
-        '',
-        'Run the following command:',
-        '',
-        '```',
-        `node bin/aw ${cmd.name} $ARGUMENTS`,
-        '```',
-        '',
-      ].filter(v => v !== null).join('\n');
-
-      writeFileSync(join(commandsDir, fileName), content);
-      count++;
+    const nsDir = join(awDir, ns);
+    if (existsSync(nsDir)) {
+      const cmdFiles = findFiles(nsDir, 'commands');
+      count += cmdFiles.length;
     }
-
-  }
-
-  // Codex skills — .agents/skills/<name>/SKILL.md
-  const agentsSkillsDir = join(cwd, '.agents/skills');
-  mkdirSync(agentsSkillsDir, { recursive: true });
-  for (const cmd of AW_COMMANDS) {
-    const skillDir = join(agentsSkillsDir, cmd.name);
-    mkdirSync(skillDir, { recursive: true });
-    const content = [
-      '---',
-      `name: ${cmd.name}`,
-      `description: ${cmd.description}`,
-      '---',
-      '',
-      `Run: \`node bin/aw ${cmd.name}\` followed by the user's arguments.`,
-      '',
-    ].join('\n');
-    writeFileSync(join(skillDir, 'SKILL.md'), content);
   }
 
   if (count > 0) {
@@ -88,6 +34,27 @@ export function generateCommands(cwd) {
   return count;
 }
 
+function findFiles(dir, typeName) {
+  const results = [];
+  function walk(d) {
+    for (const entry of readdirSync(d, { withFileTypes: true })) {
+      if (entry.name.startsWith('.')) continue;
+      const full = join(d, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === typeName) {
+          for (const f of readdirSync(full)) {
+            if (f.endsWith('.md')) results.push(join(full, f));
+          }
+        } else {
+          walk(full);
+        }
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
 /**
  * Copy CLAUDE.md and AGENTS.md to project root.
  */
@@ -460,10 +427,13 @@ No active tasks. Tasks are created during workflow execution.
   fmt.logSuccess('Created .aw_docs/ (local orchestration state)');
 }
 
-function listNamespaceDirs(awDir) {
-  if (!existsSync(awDir)) return [];
-  return readdirSync(awDir, { withFileTypes: true })
-    .filter(d => d.isDirectory() && !d.name.startsWith('.'))
-    .map(d => d.name);
+/**
+ * Return team namespace paths from config (excludes 'platform').
+ * E.g. ['revex/courses'] — generated CLI commands only go into team namespaces.
+ */
+function getTeamNamespaces(awDir) {
+  const cfg = config.load(awDir);
+  if (!cfg || !cfg.include) return [];
+  return cfg.include.filter(p => p !== 'platform');
 }
 

package/package.json

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

package/plan.mjs

@@ -24,11 +24,12 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
         continue;
       }
 
-      // For skill files: key includes relative path to avoid collisions
-      // For other files: key is type/slug
+      // Key must include namespacePath to avoid collisions when the same
+      // slug exists under different domains (e.g. backend/agents/developer
+      // vs frontend/agents/developer).
       const key = entry.skillRelPath
-        ? `${entry.type}/${entry.slug}/${entry.skillRelPath}`
-        : `${entry.type}/${entry.slug}`;
+        ? `${entry.namespacePath}/${entry.type}/${entry.slug}/${entry.skillRelPath}`
+        : `${entry.namespacePath}/${entry.type}/${entry.slug}`;
       plan.set(key, { ...entry, source: entry.namespacePath || name });
     }
   }
@@ -108,9 +109,10 @@ export function computePlan(registryDirs, workspaceDir, includePatterns = [], {
         }
       }
       if (typeIdx === -1) continue;
+      const namespace = parts.slice(0, typeIdx).join('/');
       const type = parts[typeIdx];
       const slug = parts[typeIdx + 1]?.replace(/\.md$/, '');
-      const key = `${type}/${slug}`;
+      const key = `${namespace}/${type}/${slug}`;
       if (!plan.has(key)) {
         actions.push({
           slug,