@ghl-ai/aw 0.1.36-beta.6 → 0.1.36-beta.61

package/cli.mjs

@@ -65,7 +65,8 @@ function parseArgs(argv) {
 
 function printHelp() {
   fmt.banner('aw', {
-    subtitle: `  ${chalk.dim('v' + VERSION)}  ${chalk.hex('#FF6B35')('Agentic Workspace CLI')}  ${chalk.dim('— pull, push & manage agents, skills and more from the registry')}`,
+    icon: '⟁',
+    subtitle: `  ${chalk.hex('#FF6B35')('⟁')}  ${chalk.dim('v' + VERSION)}  ${chalk.hex('#FF6B35')('Agentic Workspace CLI')}  ${chalk.dim('— pull, push & manage agents, skills and more from the registry')}`,
   });
 
   const cmd = (c, d) => `  ${chalk.hex('#FF6B35')(c.padEnd(38))} ${chalk.dim(d)}`;
@@ -92,6 +93,7 @@ function printHelp() {
 
     sec('Manage'),
     cmd('aw status', 'Show synced paths, modified files & conflicts'),
+    cmd('aw link', 'Link current project as a git worktree (wires IDE symlinks)'),
     cmd('aw drop <path>', 'Stop syncing or delete local content'),
     cmd('aw nuke', 'Remove entire .aw_registry/ & start fresh'),
     cmd('aw daemon install', 'Auto-pull on a schedule (macOS launchd / Linux cron)'),

package/commands/daemon.mjs

@@ -2,12 +2,15 @@
 // that silently runs `aw pull` on a schedule without any user interaction.
 
 import { existsSync, writeFileSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+import { execSync, exec as execCb } from 'node:child_process';
+import { promisify } from 'node:util';
 import { join } from 'node:path';
 import { homedir, platform } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 
+const exec = promisify(execCb);
+
 const LABEL = 'ai.ghl.aw.pull';
 const PLIST_PATH = join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
 const DEFAULT_INTERVAL = 3600; // 1 hour in seconds
@@ -22,7 +25,7 @@ function getAwBin() {
 
 // ── macOS: launchd ──────────────────────────────────────────────────────────
 
-function installLaunchd(intervalSeconds) {
+async function installLaunchd(intervalSeconds) {
   const awBin = getAwBin();
   const logDir = join(homedir(), '.aw_registry', 'logs');
   if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
@@ -63,22 +66,24 @@ function installLaunchd(intervalSeconds) {
 
   writeFileSync(PLIST_PATH, plist);
 
-  // Unload first if already loaded (to apply new interval)
-  try { execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`); } catch { /* not loaded */ }
-  execSync(`launchctl load "${PLIST_PATH}"`);
-
-  fmt.logStep(`Daemon installed — runs every ${formatInterval(intervalSeconds)}`);
-  fmt.logStep(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
+  const s = fmt.spinner();
+  s.start('Installing daemon...');
+  try { await exec(`launchctl unload "${PLIST_PATH}" 2>/dev/null`); } catch { /* not loaded */ }
+  await exec(`launchctl load "${PLIST_PATH}"`);
+  s.stop(`Daemon installed — runs every ${formatInterval(intervalSeconds)}`);
+  fmt.logInfo(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
 }
 
-function uninstallLaunchd() {
+async function uninstallLaunchd() {
   if (!existsSync(PLIST_PATH)) {
     fmt.logStep('No daemon installed.');
     return;
   }
-  try { execSync(`launchctl unload "${PLIST_PATH}"`); } catch { /* ignore */ }
+  const s = fmt.spinner();
+  s.start('Removing daemon...');
+  try { await exec(`launchctl unload "${PLIST_PATH}"`); } catch { /* ignore */ }
   unlinkSync(PLIST_PATH);
-  fmt.logStep('Daemon removed.');
+  s.stop('Daemon removed.');
 }
 
 function statusLaunchd() {
@@ -102,7 +107,7 @@ function toCronExpression(intervalSeconds) {
   return `0 */${hours} * * *`;
 }
 
-function installCron(intervalSeconds) {
+async function installCron(intervalSeconds) {
   const awBin = getAwBin();
   const logDir = join(homedir(), '.aw_registry', 'logs');
   if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
@@ -117,17 +122,21 @@ function installCron(intervalSeconds) {
   const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
   const updated = cleaned.trimEnd() + '\n' + cronLine + '\n';
 
-  execSync(`echo ${JSON.stringify(updated)} | crontab -`);
-  fmt.logStep(`Cron job installed — runs every ${formatInterval(intervalSeconds)}`);
-  fmt.logStep(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
+  const s = fmt.spinner();
+  s.start('Installing cron job...');
+  await exec(`echo ${JSON.stringify(updated)} | crontab -`);
+  s.stop(`Cron job installed — runs every ${formatInterval(intervalSeconds)}`);
+  fmt.logInfo(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
 }
 
-function uninstallCron() {
+async function uninstallCron() {
   let current = '';
   try { current = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' }); } catch { return; }
   const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
-  execSync(`echo ${JSON.stringify(cleaned)} | crontab -`);
-  fmt.logStep('Cron job removed.');
+  const s = fmt.spinner();
+  s.start('Removing cron job...');
+  await exec(`echo ${JSON.stringify(cleaned)} | crontab -`);
+  s.stop('Cron job removed.');
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
@@ -148,7 +157,7 @@ function parseInterval(str) {
 
 // ── Main ─────────────────────────────────────────────────────────────────────
 
-export function daemonCommand(args) {
+export async function daemonCommand(args) {
   const subcommand = args._positional[0] || 'install';
   const interval = parseInterval(args['--interval'] || args._positional[1]);
   const isMac = platform() === 'darwin';
@@ -158,13 +167,13 @@ export function daemonCommand(args) {
   if (subcommand === 'install') {
     fmt.logStep(`Platform: ${isMac ? 'macOS (launchd)' : 'Linux (cron)'}`);
     fmt.logStep(`Interval: every ${formatInterval(interval)}`);
-    if (isMac) installLaunchd(interval);
-    else installCron(interval);
+    if (isMac) await installLaunchd(interval);
+    else await installCron(interval);
     fmt.outro(`aw pull will run silently every ${formatInterval(interval)}`);
 
   } else if (subcommand === 'uninstall' || subcommand === 'stop') {
-    if (isMac) uninstallLaunchd();
-    else uninstallCron();
+    if (isMac) await uninstallLaunchd();
+    else await uninstallCron();
     fmt.outro('Daemon stopped.');
 
   } else if (subcommand === 'status') {

package/commands/drop.mjs

@@ -80,7 +80,7 @@ export function dropCommand(args) {
   }
 
   // Re-link to remove dead symlinks
-  linkWorkspace(HOME);
+  linkWorkspace(HOME, null, { silent: true });
 
-  fmt.outro('Done');
+  fmt.outro(`⟁  Dropped ${chalk.cyan(regPath)}`);
 }

package/commands/init.mjs

@@ -4,12 +4,11 @@
 // Uses core.hooksPath (git-lfs pattern) for system-wide hook interception.
 // Uses IDE tasks for auto-pull on workspace open.
 
-import { existsSync, writeFileSync, symlinkSync, lstatSync, readdirSync } from 'node:fs';
+import { existsSync, writeFileSync, symlinkSync, lstatSync, readdirSync, readFileSync, rmSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
@@ -30,7 +29,7 @@ import {
   sparseCheckoutAsync,
   cleanup,
 } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL } from '../constants.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
@@ -91,7 +90,6 @@ export async function initCommand(args) {
   let nsParts = namespace ? namespace.split('/') : [];
   let team = nsParts[0] || null;
   let subTeam = nsParts[1] || null;
-  let teamNS = subTeam ? `${team}-${subTeam}` : team;
   let folderName = subTeam ? `${team}/${subTeam}` : team;
 
   if (team && !ALLOWED_NAMESPACES.includes(team)) {
@@ -125,7 +123,7 @@ export async function initCommand(args) {
 
   // ── Detect installation state ─────────────────────────────────────────
 
-  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  const repoUrl = REGISTRY_URL;
   const isGitNative = isValidClone(AW_HOME, repoUrl);
   const isLegacy = !isGitNative && existsSync(GLOBAL_AW_DIR) && !lstatSync(GLOBAL_AW_DIR).isSymbolicLink();
 
@@ -133,6 +131,8 @@ export async function initCommand(args) {
 
   let namespaceExistsInRemote = false;
   if (folderName && !silent && !isGitNative && !isLegacy) {
+    const probeSpinner = fmt.spinner();
+    probeSpinner.start(`Checking namespace ${chalk.cyan(folderName)} in registry...`);
     try {
       const probePaths = includeToSparsePaths([folderName]);
       const probeDir = await sparseCheckoutAsync(REGISTRY_REPO, probePaths);
@@ -144,7 +144,11 @@ export async function initCommand(args) {
       } finally {
         cleanup(probeDir);
       }
+      probeSpinner.stop(namespaceExistsInRemote
+        ? `Namespace ${chalk.cyan(folderName)} found in registry`
+        : `Namespace ${chalk.cyan(folderName)} not yet in registry`);
     } catch {
+      probeSpinner.stop(chalk.dim('Could not verify namespace (continuing)'));
       namespaceExistsInRemote = true;
     }
   }
@@ -164,7 +168,7 @@ export async function initCommand(args) {
     }
 
     if (choice === 'platform-only') {
-      namespace = null; team = null; subTeam = null; teamNS = null; folderName = null;
+      namespace = null; team = null; subTeam = null; folderName = null;
     }
   }
 
@@ -185,13 +189,13 @@ export async function initCommand(args) {
       if (!silent) fmt.logStep('Already initialized — syncing...');
     }
 
-    const s = fmt.spinner ? fmt.spinner() : { start: () => {}, stop: () => {} };
-    if (!silent) s.start('Fetching latest...');
+    const s = fmt.spinner();
+    if (!silent) s.start('Fetching latest from registry...');
     try {
-      fetchAndMerge(AW_HOME);
-      if (!silent) s.stop('Registry updated');
+      await fetchAndMerge(AW_HOME);
+      if (!silent) s.stop('Registry up to date');
     } catch (e) {
-      if (!silent) s.stop(chalk.yellow('Fetch failed (continuing with local)'));
+      if (!silent) s.stop(chalk.yellow('Fetch failed — continuing with local cache'));
     }
 
     const freshCfg = config.load(GLOBAL_AW_DIR);
@@ -200,9 +204,20 @@ export async function initCommand(args) {
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
-    if (cwd !== HOME) await setupMcp(cwd, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
 
+    // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
+    if (cwd !== HOME) {
+      const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
+      try {
+        const content = readFileSync(oldLocalHook, 'utf8');
+        if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+          rmSync(oldLocalHook);
+          if (!silent) fmt.logStep('Removed legacy .git/hooks/post-checkout');
+        }
+      } catch { /* not there, fine */ }
+    }
+
     const isInsideAw = cwd.endsWith(`${sep}.aw`) || cwd.includes(`${sep}.aw${sep}`);
     if (cwd !== HOME && !isInsideAw && !isWorktree(join(cwd, '.aw'))) {
       try {
@@ -215,18 +230,18 @@ export async function initCommand(args) {
     // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
     const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
-    linkWorkspace(HOME, awDirForLinks);
-    generateCommands(HOME);
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
 
     if (silent) {
       autoUpdate(await args._updateCheck);
     } else {
       fmt.outro([
-        isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Sync complete',
+        `⟁  ${isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Up to date'}`,
         '',
-        `  ${chalk.green('✓')} Registry updated`,
-        `  ${chalk.green('✓')} IDE integration refreshed`,
-        cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Current project linked` : null,
+        `  ${chalk.green('✓')} Registry synced`,
+        `  ${chalk.green('✓')} IDE refreshed — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`,
+        cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Project linked` : null,
       ].filter(Boolean).join('\n'));
     }
     return;
@@ -271,7 +286,7 @@ export async function initCommand(args) {
   s.start(`Cloning registry...`);
 
   try {
-    initPersistentClone(repoUrl, AW_HOME, sparsePaths);
+    await initPersistentClone(repoUrl, AW_HOME, sparsePaths);
     s.stop('Registry cloned');
   } catch (e) {
     s.stop(chalk.red('Clone failed'));
@@ -279,13 +294,25 @@ export async function initCommand(args) {
   }
 
   // Create backward-compat symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/
-  if (!existsSync(GLOBAL_AW_DIR)) {
+  // Use lstatSync (not existsSync) so we handle dangling symlinks correctly.
+  let awRegistryLstat = null;
+  try { awRegistryLstat = lstatSync(GLOBAL_AW_DIR); } catch { /* doesn't exist */ }
+  if (!awRegistryLstat) {
     try {
       symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
       fmt.logStep('Created ~/.aw_registry/ symlink');
     } catch (e) {
       fmt.logWarn(`Could not create symlink ~/.aw_registry/: ${e.message}`);
     }
+  } else if (awRegistryLstat.isSymbolicLink()) {
+    // Stale or dangling — re-point to the new clone
+    try {
+      rmSync(GLOBAL_AW_DIR);
+      symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
+      fmt.logStep('Updated ~/.aw_registry/ symlink');
+    } catch (e) {
+      fmt.logWarn(`Could not update symlink ~/.aw_registry/: ${e.message}`);
+    }
   }
 
   // Create sync config
@@ -298,11 +325,21 @@ export async function initCommand(args) {
   await installAwEcc(cwd, { silent });
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
-  const mcpFiles = await setupMcp(HOME, team) || [];
-  if (cwd !== HOME) await setupMcp(cwd, team);
+  const mcpFiles = await setupMcp(HOME, team, { silent }) || [];
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
+  // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
+  if (cwd !== HOME) {
+    const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
+    try {
+      const content = readFileSync(oldLocalHook, 'utf8');
+      if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+        rmSync(oldLocalHook);
+      }
+    } catch { /* not there, fine */ }
+  }
+
   // Step 4: Link current project as a git worktree (gives IDE git panel)
   const isInsideAw = cwd.endsWith(`${sep}.aw`) || cwd.includes(`${sep}.aw${sep}`);
   if (cwd !== HOME && !isInsideAw && !isWorktree(join(cwd, '.aw'))) {
@@ -314,17 +351,20 @@ export async function initCommand(args) {
 
   // Step 5: Wire ~/.claude/.cursor/.codex to the project's registry when in a project,
   // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
-  fmt.logStep('Linking IDE symlinks...');
+  const ideSpinner = fmt.spinner();
+  ideSpinner.start('Wiring IDE symlinks...');
   const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
   const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
-  linkWorkspace(HOME, awDirForLinks);
-  generateCommands(HOME);
+  const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+  ideSpinner.message('Generating commands...');
+  const commands = generateCommands(HOME, { silent: true });
+  ideSpinner.stop(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);
 
   // Offer to update if a newer version is available
   await promptUpdate(await args._updateCheck);
 
   fmt.outro([
-    'Install complete',
+    '⟁  Install complete',
     '',
     `  ${chalk.green('✓')} Source of truth: ~/.aw/ (git clone)`,
     `  ${chalk.green('✓')} Symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/`,

package/commands/link-project.mjs

@@ -1,12 +1,12 @@
 // commands/link-project.mjs — Link current project to registry via git worktree
 
-import { existsSync } from 'node:fs';
+import { existsSync, lstatSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { addProjectWorktree, isWorktree, isValidClone } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_URL } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands } from '../integrate.mjs';
 
@@ -18,8 +18,7 @@ export function linkProjectCommand(args) {
 
   fmt.intro('aw link');
 
-  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
-  if (!isValidClone(AW_HOME, repoUrl)) {
+  if (!isValidClone(AW_HOME, REGISTRY_URL)) {
     fmt.cancel('Registry not initialized. Run: aw init');
     return;
   }
@@ -31,13 +30,17 @@ export function linkProjectCommand(args) {
 
   const worktreeDir = join(cwd, '.aw');
 
+  // Remove stale project-root .aw_registry symlink from old installs
+  const staleSymlink = join(cwd, REGISTRY_DIR);
+  try { if (lstatSync(staleSymlink).isSymbolicLink()) rmSync(staleSymlink); } catch { /* fine */ }
+
   if (isWorktree(worktreeDir)) {
     // Worktree exists — refresh global IDE symlinks pointing to this project's registry
     const projectRegistryDir = join(worktreeDir, REGISTRY_DIR);
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
-    linkWorkspace(HOME, awDirForLinks);
-    generateCommands(HOME);
-    fmt.logSuccess(`Already linked — refreshed IDE symlinks`);
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
+    fmt.logSuccess(`Already linked — refreshed ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`);
     return;
   }
 
@@ -45,10 +48,10 @@ export function linkProjectCommand(args) {
     addProjectWorktree(AW_HOME, cwd);
     const projectRegistryDir = join(worktreeDir, REGISTRY_DIR);
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
-    linkWorkspace(HOME, awDirForLinks);
-    generateCommands(HOME);
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
     fmt.logSuccess([
-      `Linked project as git worktree`,
+      `Project linked — ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`,
       '',
       `  ${chalk.green('✓')} ${chalk.dim('.aw/')}                  git worktree (IDE git panel enabled)`,
       `  ${chalk.green('✓')} ${chalk.dim(`.aw/${REGISTRY_DIR}/`)} registry content`,
@@ -58,5 +61,5 @@ export function linkProjectCommand(args) {
     fmt.cancel(`Failed to link project: ${e.message}`);
   }
 
-  fmt.outro('Done');
+  fmt.outro('⟁  Done');
 }