@ghl-ai/aw 0.1.25-beta.2 → 0.1.25-beta.3

package/commands/init.mjs

@@ -13,7 +13,7 @@ import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { pullCommand } from './pull.mjs';
+import { pullCommand, pullAsync } from './pull.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
@@ -112,6 +112,24 @@ function saveManifest(data) {
 }
 
 
+function printPullSummary(pattern, actions) {
+  for (const type of ['agents', 'skills', 'commands', 'evals']) {
+    const typeActions = actions.filter(a => a.type === type);
+    if (typeActions.length === 0) continue;
+
+    const counts = { ADD: 0, UPDATE: 0, CONFLICT: 0 };
+    for (const a of typeActions) counts[a.action] = (counts[a.action] || 0) + 1;
+
+    const parts = [];
+    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`));
+    const detail = parts.length > 0 ? ` (${parts.join(', ')})` : '';
+
+    fmt.logSuccess(`${chalk.cyan(pattern)}: ${typeActions.length} ${type}${detail}`);
+  }
+}
+
 const ALLOWED_NAMESPACES = ['revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
 export async function initCommand(args) {
@@ -150,7 +168,9 @@ export async function initCommand(args) {
     fmt.cancel(`Invalid namespace '${namespace}' — must match: ^[a-z][a-z0-9-]{1,38}[a-z0-9]$`);
   }
 
-  const isExisting = config.exists(GLOBAL_AW_DIR);
+  const hasConfig = config.exists(GLOBAL_AW_DIR);
+  const hasPlatform = existsSync(join(GLOBAL_AW_DIR, 'platform'));
+  const isExisting = hasConfig && hasPlatform;
   const cwd = process.cwd();
 
   // ── Fast path: already initialized → just pull + link ─────────────────
@@ -209,27 +229,46 @@ export async function initCommand(args) {
     `${chalk.dim('version:')}    v${VERSION}`,
   ].filter(Boolean).join('\n'), 'Config created');
 
-  // Step 2: Pull registry content
-  pullCommand({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR });
+  // Step 2: Pull registry content (parallel)
+  const s = fmt.spinner();
+  const pullTargets = namespace ? `platform + ${namespace}` : 'platform';
+  s.start(`Pulling ${pullTargets}...`);
 
+  const pullJobs = [
+    pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
+  ];
   if (namespace) {
-    pullCommand({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR });
+    pullJobs.push(
+      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: namespace, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
+    );
   }
 
-  // Step 3: Link to global IDE dirs
+  let pullResults;
+  try {
+    pullResults = await Promise.all(pullJobs);
+    s.stop(`Pulled ${pullTargets}`);
+  } catch (e) {
+    s.stop(chalk.red('Pull failed'));
+    fmt.cancel(e.message);
+  }
+
+  for (const { pattern, actions } of pullResults) {
+    printPullSummary(pattern, actions);
+  }
+
+  // Step 3: Link IDE dirs + parallel setup tasks
   linkWorkspace(HOME);
   generateCommands(HOME);
   const instructionFiles = copyInstructions(HOME, null, namespace) || [];
-  initAwDocs(HOME);
-  const mcpFiles = setupMcp(HOME, namespace) || [];
-
-  // Step 4: Git template hook (omnipresence)
-  const gitTemplateInstalled = installGitTemplate();
 
-  // Step 5: IDE auto-init tasks
-  installIdeTasks();
+  const [, , mcpFiles, gitTemplateInstalled] = await Promise.all([
+    Promise.resolve(initAwDocs(HOME)),
+    Promise.resolve(installIdeTasks()),
+    Promise.resolve(setupMcp(HOME, namespace) || []),
+    Promise.resolve(installGitTemplate()),
+  ]);
 
-  // Step 6: Symlink in current directory if it's a git repo
+  // Step 4: Symlink in current directory if it's a git repo
   if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
     try {
       symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
@@ -237,7 +276,7 @@ export async function initCommand(args) {
     } catch { /* best effort */ }
   }
 
-  // Step 7: Write manifest for nuke cleanup
+  // Step 5: Write manifest for nuke cleanup
   const manifest = {
     version: 1,
     installedAt: new Date().toISOString(),

package/commands/pull.mjs

@@ -7,7 +7,7 @@ import { execSync } from 'node:child_process';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { sparseCheckout, cleanup, includeToSparsePaths } from '../git.mjs';
+import { sparseCheckout, sparseCheckoutAsync, cleanup, includeToSparsePaths } from '../git.mjs';
 import { walkRegistryTree } from '../registry.mjs';
 import { matchesAny } from '../glob.mjs';
 import { computePlan } from '../plan.mjs';
@@ -191,6 +191,82 @@ export function pullCommand(args) {
   }
 }
 
+/**
+ * Async pull for parallel use by init. Runs git fetch asynchronously,
+ * then applies changes synchronously. Returns a summary object instead
+ * of printing directly — the caller controls output.
+ */
+export async function pullAsync(args) {
+  const input = args._positional?.[0] || '';
+  const workspaceDir = args._workspaceDir;
+  const renameNamespace = args._renameNamespace || null;
+
+  const resolved = resolveInput(input, workspaceDir);
+  let pattern = resolved.registryPath;
+  if (!pattern) throw new Error(`Could not resolve "${input}" to a registry path`);
+
+  if (!existsSync(workspaceDir)) mkdirSync(workspaceDir, { recursive: true });
+
+  const cfg = config.load(workspaceDir);
+  if (!cfg) throw new Error('No .sync-config.json found');
+
+  const sparsePaths = includeToSparsePaths([pattern]);
+  const tempDir = await sparseCheckoutAsync(cfg.repo, sparsePaths);
+
+  try {
+    const registryDirs = [];
+    const regBase = join(tempDir, 'registry');
+
+    if (existsSync(regBase)) {
+      for (const name of listDirs(regBase)) {
+        registryDirs.push({ name, path: join(regBase, name) });
+      }
+    }
+
+    if (registryDirs.length === 0) {
+      throw new Error(`Nothing found in registry for ${pattern}`);
+    }
+
+    if (renameNamespace) {
+      for (const rd of registryDirs) {
+        if (rd.name === pattern) rd.name = renameNamespace;
+      }
+      pattern = renameNamespace;
+    }
+
+    let hasMatch = false;
+    for (const { name, path } of registryDirs) {
+      const entries = walkRegistryTree(path, name);
+      if (entries.some(e => matchesAny(e.registryPath, [pattern]))) {
+        hasMatch = true;
+        break;
+      }
+    }
+
+    if (!hasMatch) {
+      throw new Error(`Nothing found in registry for ${pattern}`);
+    }
+
+    if (!cfg.include.includes(pattern)) {
+      config.addPattern(workspaceDir, pattern);
+    }
+
+    const { actions } = computePlan(registryDirs, workspaceDir, [pattern], { skipOrphans: true });
+    const conflictCount = applyActions(actions, { teamNS: renameNamespace || undefined });
+    updateManifest(workspaceDir, actions, cfg.namespace);
+
+    const ROOT_REGISTRY_FILES = ['AW-PROTOCOL.md'];
+    for (const fname of ROOT_REGISTRY_FILES) {
+      const src = join(regBase, fname);
+      if (existsSync(src)) copyFileSync(src, join(workspaceDir, fname));
+    }
+
+    return { pattern, actions, conflictCount };
+  } finally {
+    cleanup(tempDir);
+  }
+}
+
 function listDirs(dir) {
   return readdirSync(dir, { withFileTypes: true })
     .filter(d => d.isDirectory() && !d.name.startsWith('.'))

package/git.mjs

@@ -1,13 +1,16 @@
 // git.mjs — Git sparse checkout helpers. Zero dependencies.
 
-import { execSync } from 'node:child_process';
+import { execSync, exec as execCb } from 'node:child_process';
 import { mkdtempSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { promisify } from 'node:util';
 import { REGISTRY_BASE_BRANCH } from './constants.mjs';
 
+const exec = promisify(execCb);
+
 /**
- * Sparse-checkout registry paths from GitHub.
+ * Sparse-checkout registry paths from GitHub (sync).
  * Returns the temp directory path containing the checkout.
  */
 export function sparseCheckout(repo, paths) {
@@ -35,6 +38,31 @@ export function sparseCheckout(repo, paths) {
   return tempDir;
 }
 
+/**
+ * Sparse-checkout registry paths from GitHub (async).
+ * Same as sparseCheckout but non-blocking — can run in parallel.
+ */
+export async function sparseCheckoutAsync(repo, paths) {
+  const tempDir = mkdtempSync(join(tmpdir(), 'aw-'));
+
+  const repoUrl = repo.startsWith('http') ? repo : `https://github.com/${repo}.git`;
+  try {
+    await exec(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${tempDir}"`);
+  } catch (e) {
+    throw new Error(`Failed to clone ${repo}. Check your git credentials and repo access.`);
+  }
+
+  try {
+    await exec('git sparse-checkout init --cone', { cwd: tempDir });
+    await exec(`git sparse-checkout set --skip-checks ${paths.map(p => `"${p}"`).join(' ')}`, { cwd: tempDir });
+    await exec(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: tempDir });
+  } catch (e) {
+    throw new Error(`Failed sparse checkout: ${e.message}`);
+  }
+
+  return tempDir;
+}
+
 /**
  * Clean up temp directory.
  */

package/package.json

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