@ghl-ai/aw 0.1.36-beta.1 → 0.1.36-beta.2

package/commands/drop.mjs

@@ -2,87 +2,85 @@
 
 import { join, resolve } from 'node:path';
 import { rmSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { matchesAny } from '../glob.mjs';
 import { resolveInput } from '../paths.mjs';
-import { load as loadManifest, save as saveManifest } from '../manifest.mjs';
+import { removeFromSparseCheckout, isValidClone } from '../git.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { linkWorkspace } from '../link.mjs';
 
 export function dropCommand(args) {
   const input = args._positional?.[0];
   const cwd = process.cwd();
+
+  const HOME = homedir();
+  const AW_HOME = join(HOME, '.aw');
+  const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
   const workspaceDir = join(cwd, '.aw_registry');
 
   fmt.intro('aw drop');
 
   if (!input) {
-    fmt.cancel('Missing target. Usage:\n  aw drop example-team                         (stop syncing namespace)\n  aw drop example-team/skills/example-skill     (stop syncing skill)\n  aw drop example-team/skills/example-skill/SKILL  (delete single file)');
+    fmt.cancel('Missing target. Usage:\n  aw drop example-team                         (stop syncing namespace)\n  aw drop example-team/skills/example-skill     (stop syncing skill)');
+    return;
   }
 
-  const cfg = config.load(workspaceDir);
-  if (!cfg) fmt.cancel('No .sync-config.json found. Run: aw init');
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  if (!isValidClone(AW_HOME, repoUrl)) {
+    fmt.cancel('Registry not initialized. Run: aw init');
+    return;
+  }
 
-  // Resolve to registry path (accepts both local and registry paths)
+  const cfg = config.load(GLOBAL_AW_DIR);
+  if (!cfg) {
+    fmt.cancel('No .sync-config.json found. Run: aw init');
+    return;
+  }
+
+  // Resolve to registry path
   const resolved = resolveInput(input, workspaceDir);
   const regPath = resolved.registryPath;
 
   if (!regPath) {
     fmt.cancel(`Could not resolve "${input}" to a registry path`);
+    return;
   }
 
-  // Check if this path (or a parent) is in config → remove from config + delete files
+  // Check if this path (or a parent) is in config
   const isConfigPath = cfg.include.some(p => p === regPath || p.startsWith(regPath + '/'));
 
   if (isConfigPath) {
-    config.removePattern(workspaceDir, regPath);
+    // Remove from sparse checkout
+    try {
+      removeFromSparseCheckout(AW_HOME, [`${REGISTRY_DIR}/${regPath}`]);
+    } catch (e) {
+      fmt.logWarn(`Could not update sparse checkout: ${e.message}`);
+    }
+
+    config.removePattern(GLOBAL_AW_DIR, regPath);
     fmt.logSuccess(`Removed ${chalk.cyan(regPath)} from sync config`);
   }
 
-  // Delete matching local files
-  const removed = deleteMatchingFiles(workspaceDir, regPath);
+  // Count removed files (they disappear from working tree via sparse checkout)
+  const registryAbsPath = join(AW_HOME, REGISTRY_DIR, regPath);
+  let removed = 0;
+  if (!existsSync(registryAbsPath)) {
+    removed = 1; // sparse checkout removed it
+  }
 
-  if (removed > 0) {
-    fmt.logInfo(`${chalk.bold(removed)} file${removed > 1 ? 's' : ''} removed from workspace`);
-  } else if (!isConfigPath) {
+  if (!isConfigPath && removed === 0) {
     fmt.cancel(`Nothing found for ${chalk.cyan(regPath)}.\n\n  Use ${chalk.dim('aw status')} to see synced paths.`);
+    return;
   }
 
-  if (!isConfigPath && removed > 0) {
-    fmt.logWarn(`Path still in sync config — next ${chalk.dim('aw pull')} will restore it`);
+  if (!isConfigPath) {
+    fmt.logWarn(`Path was not in sync config — no sparse checkout change made`);
   }
 
-  fmt.outro('Done');
-}
+  // Re-link to remove dead symlinks
+  linkWorkspace(HOME);
 
-/**
- * Find and delete local files whose registry path matches the given path.
- */
-function deleteMatchingFiles(workspaceDir, path) {
-  const manifest = loadManifest(workspaceDir);
-  let removed = 0;
-
-  for (const [manifestKey] of Object.entries(manifest.files)) {
-    const registryPath = manifestKeyToRegistryPath(manifestKey);
-
-    if (matchesAny(registryPath, [path])) {
-      const filePath = join(workspaceDir, manifestKey);
-      if (existsSync(filePath)) {
-        rmSync(filePath, { recursive: true, force: true });
-        removed++;
-      }
-      delete manifest.files[manifestKey];
-    }
-  }
-
-  saveManifest(workspaceDir, manifest);
-  return removed;
-}
-
-/**
- * Convert manifest key to registry path.
- * Manifest key now mirrors registry: "platform/agents/architecture-reviewer.md" → "platform/agents/architecture-reviewer"
- */
-function manifestKeyToRegistryPath(manifestKey) {
-  return manifestKey.replace(/\.md$/, '');
+  fmt.outro('Done');
 }

package/commands/init.mjs

@@ -1,10 +1,10 @@
-// commands/init.mjs — Clean init: clone registry, link IDEs, global git hooks.
+// commands/init.mjs — Clean init: persistent git clone of registry, link IDEs, global git hooks.
 //
 // No shell profile modifications. No daemons. No background processes.
 // Uses core.hooksPath (git-lfs pattern) for system-wide hook interception.
 // Uses IDE tasks for auto-pull on workspace open.
 
-import { mkdirSync, existsSync, writeFileSync, symlinkSync, readdirSync } from 'node:fs';
+import { existsSync, writeFileSync, symlinkSync, lstatSync, readdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
@@ -13,27 +13,33 @@ import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { pullCommand, pullAsync } from './pull.mjs';
-import { sparseCheckoutAsync, includeToSparsePaths, cleanup } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
 import { installGlobalHooks } from '../hooks.mjs';
 import { installAwEcc } from '../ecc.mjs';
+import {
+  initPersistentClone,
+  isValidClone,
+  fetchAndMerge,
+  addToSparseCheckout,
+  includeToSparsePaths,
+  sparseCheckoutAsync,
+  cleanup,
+} from '../git.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
-const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
+const AW_HOME = join(HOME, '.aw');
 
 // ── IDE tasks for auto-pull ─────────────────────────────────────────────
 
 function installIdeTasks() {
-  // VS Code / Cursor task — runs aw pull on folder open
   const vscodeTask = {
     version: '2.0.0',
     tasks: [
@@ -48,18 +54,15 @@ function installIdeTasks() {
     ],
   };
 
-  // Install globally for VS Code and Cursor
   for (const ide of ['Code', 'Cursor']) {
     const userDir = join(HOME, 'Library', 'Application Support', ide, 'User');
     if (!existsSync(userDir)) continue;
 
     const tasksPath = join(userDir, 'tasks.json');
     if (existsSync(tasksPath)) {
-      // Don't override existing tasks — check if aw task already there
       try {
         const existing = JSON.parse(readFileSync(tasksPath, 'utf8'));
         if (existing.tasks?.some(t => t.label === 'aw: sync registry' || t.label === 'aw: pull registry')) continue;
-        // Add our task to existing
         existing.tasks = existing.tasks || [];
         existing.tasks.push(vscodeTask.tasks[0]);
         writeFileSync(tasksPath, JSON.stringify(existing, null, 2) + '\n');
@@ -72,29 +75,6 @@ function installIdeTasks() {
   }
 }
 
-function saveManifest(data) {
-  writeFileSync(MANIFEST_PATH, JSON.stringify(data, null, 2) + '\n');
-}
-
-
-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 = ['platform', 'revex', 'mobile', 'commerce', 'leadgen', 'crm', 'marketplace', 'ai'];
 
 export async function initCommand(args) {
@@ -106,12 +86,11 @@ export async function initCommand(args) {
 
   // ── Validate ──────────────────────────────────────────────────────────
 
-  // Parse team/sub-team
   let nsParts = namespace ? namespace.split('/') : [];
   let team = nsParts[0] || null;
   let subTeam = nsParts[1] || null;
-  let teamNS = subTeam ? `${team}-${subTeam}` : team;          // for $TEAM_NS replacement
-  let folderName = subTeam ? `${team}/${subTeam}` : team;       // for .aw_registry/ path
+  let teamNS = subTeam ? `${team}-${subTeam}` : team;
+  let folderName = subTeam ? `${team}/${subTeam}` : team;
 
   if (team && !ALLOWED_NAMESPACES.includes(team)) {
     const list = ALLOWED_NAMESPACES.map(n => chalk.cyan(n)).join(', ');
@@ -142,10 +121,16 @@ export async function initCommand(args) {
     fmt.cancel(`Invalid sub-team '${subTeam}' — must match: ${SLUG_RE}`);
   }
 
-  // ── Probe remote registry to check if namespace exists ────────────────
+  // ── Detect installation state ─────────────────────────────────────────
+
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  const isGitNative = isValidClone(AW_HOME, repoUrl);
+  const isLegacy = !isGitNative && existsSync(GLOBAL_AW_DIR) && !lstatSync(GLOBAL_AW_DIR).isSymbolicLink();
+
+  // ── Probe remote registry to check if namespace exists (fresh install only) ──
 
   let namespaceExistsInRemote = false;
-  if (folderName && !silent) {
+  if (folderName && !silent && !isGitNative && !isLegacy) {
     try {
       const probePaths = includeToSparsePaths([folderName]);
       const probeDir = await sparseCheckoutAsync(REGISTRY_REPO, probePaths);
@@ -158,18 +143,16 @@ export async function initCommand(args) {
         cleanup(probeDir);
       }
     } catch {
-      // Network error — skip probe, proceed without prompt
       namespaceExistsInRemote = true;
     }
   }
 
-  // If namespace does NOT exist in remote, ask user to confirm
-  if (folderName && !silent && !namespaceExistsInRemote && process.stdin.isTTY) {
+  if (folderName && !silent && !isGitNative && !isLegacy && !namespaceExistsInRemote && process.stdin.isTTY) {
     const choice = await fmt.select({
-      message: `The namespace '${folderName}' does not exist in the registry yet and will be created from [template].\nplatform/ includes shared agents, skills & commands that cover most use cases.\nHow would you like to proceed?`,
+      message: `The namespace '${folderName}' does not exist in the registry yet.\nplatform/ includes shared agents, skills & commands that cover most use cases.\nHow would you like to proceed?`,
       options: [
         { value: 'platform-only', label: 'Continue with platform/ only (recommended for most users)' },
-        { value: 'create-namespace', label: `Create '${folderName}' namespace from template` },
+        { value: 'create-namespace', label: `Use '${folderName}' namespace (will be created)` },
       ],
     });
 
@@ -183,58 +166,34 @@ export async function initCommand(args) {
     }
   }
 
-  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 ─────────────────
+  // ── Re-init path: already set up with native git clone ────────────────
 
-  if (isExisting) {
+  if (isGitNative) {
     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,
-      });
+      const newSparsePaths = [`.aw_registry/${folderName}`, `content`];
+      addToSparseCheckout(AW_HOME, newSparsePaths);
       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/courses'), but the repo
-    // only has '.aw_registry/[template]/' — remap non-platform entries back.
-    // Platform is never stored in cfg.include but must always be pulled.
-    const freshCfg = config.load(GLOBAL_AW_DIR);
-    const pullJobs = [
-      pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
-    ];
-    if (freshCfg && freshCfg.include.length > 0) {
-      for (const p of freshCfg.include) {
-        if (p === 'platform') continue; // already added above
-        const derivedTeamNS = p.replace(/\//g, '-');
-        pullJobs.push(pullAsync({
-          ...args,
-          _positional: ['[template]'],
-          _workspaceDir: GLOBAL_AW_DIR,
-          _skipIntegrate: true,
-          _renameNamespace: p,
-          _teamNS: derivedTeamNS,
-        }));
-      }
+    const s = fmt.spinner ? fmt.spinner() : { start: () => {}, stop: () => {} };
+    if (!silent) s.start('Fetching latest...');
+    try {
+      fetchAndMerge(AW_HOME);
+      if (!silent) s.stop('Registry updated');
+    } catch (e) {
+      if (!silent) s.stop(chalk.yellow('Fetch failed (continuing with local)'));
     }
-    await Promise.all(pullJobs);
 
-    // Re-link IDE dirs + hooks (idempotent)
+    const freshCfg = config.load(GLOBAL_AW_DIR);
+
     linkWorkspace(HOME);
     await installAwEcc(cwd, { silent });
     generateCommands(HOME);
@@ -244,7 +203,6 @@ export async function initCommand(args) {
     if (cwd !== HOME) await setupMcp(cwd, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
 
-    // Link current project if needed
     if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
       try {
         symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
@@ -266,52 +224,66 @@ export async function initCommand(args) {
     return;
   }
 
+  // ── Legacy migration: old ~/.aw_registry/ dir → notify user ──────────
+
+  if (isLegacy) {
+    if (!silent) {
+      fmt.logWarn([
+        'Legacy installation detected (~/.aw_registry/ is a plain directory).',
+        '',
+        `  Run ${chalk.bold('aw nuke')} first to remove the old install, then ${chalk.bold('aw init')} again.`,
+        `  This will migrate to the new native git clone at ~/.aw/`,
+      ].join('\n'));
+    }
+    // Fall through to full init — create AW_HOME fresh
+  }
+
   // ── Full init: first time setup ───────────────────────────────────────
 
-  // Auto-detect user
   if (!user) {
     try {
       user = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
     } catch { /* git not configured */ }
   }
 
-  // Step 1: Create global source of truth
-  mkdirSync(GLOBAL_AW_DIR, { recursive: true });
-
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
+  // Determine sparse paths
+  const sparsePaths = [`.aw_registry/platform`, `content`, `.aw_registry/AW-PROTOCOL.md`];
+  if (folderName) {
+    sparsePaths.push(`.aw_registry/${folderName}`);
+  }
 
   fmt.note([
-    `${chalk.dim('source:')}     ~/.aw_registry/`,
+    `${chalk.dim('source:')}     ~/.aw/ → ~/.aw_registry/ (symlink)`,
     folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
-    user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
+    user ? `${chalk.dim('user:')}       ${user}` : null,
     `${chalk.dim('version:')}    v${VERSION}`,
-  ].filter(Boolean).join('\n'), 'Config created');
+  ].filter(Boolean).join('\n'), 'Config');
 
-  // Step 2: Pull registry content (parallel)
   const s = fmt.spinner();
-  const pullTargets = folderName ? `platform + ${folderName}` : 'platform';
-  s.start(`Pulling ${pullTargets}...`);
-
-  const pullJobs = [
-    pullAsync({ ...args, _positional: ['platform'], _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
-  ];
-  if (folderName) {
-    pullJobs.push(
-      pullAsync({ ...args, _positional: ['[template]'], _renameNamespace: folderName, _teamNS: teamNS, _workspaceDir: GLOBAL_AW_DIR, _skipIntegrate: true }),
-    );
-  }
+  s.start(`Cloning registry...`);
 
-  let pullResults;
   try {
-    pullResults = await Promise.all(pullJobs);
-    s.stop(`Pulled ${pullTargets}`);
+    initPersistentClone(repoUrl, AW_HOME, sparsePaths);
+    s.stop('Registry cloned');
   } catch (e) {
-    s.stop(chalk.red('Pull failed'));
+    s.stop(chalk.red('Clone failed'));
     fmt.cancel(e.message);
   }
 
-  for (const { pattern, actions } of pullResults) {
-    printPullSummary(pattern, actions);
+  // Create backward-compat symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/
+  if (!existsSync(GLOBAL_AW_DIR)) {
+    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}`);
+    }
+  }
+
+  // Create sync config
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
+  if (folderName) {
+    config.addPattern(GLOBAL_AW_DIR, folderName);
   }
 
   // Step 3: Link IDE dirs + setup tasks
@@ -334,27 +306,14 @@ export async function initCommand(args) {
     } catch { /* best effort */ }
   }
 
-  // Step 5: Write manifest for nuke cleanup
-  const manifest = {
-    version: 1,
-    installedAt: new Date().toISOString(),
-    globalDir: GLOBAL_AW_DIR,
-    createdFiles: [
-      ...instructionFiles.map(p => p.startsWith(HOME) ? p.slice(HOME.length + 1) : p),
-      ...mcpFiles.map(p => p.startsWith(HOME) ? p.slice(HOME.length + 1) : p),
-    ],
-    globalHooksDir: hooksInstalled ? join(HOME, '.aw', 'hooks') : null,
-  };
-  saveManifest(manifest);
-
   // Offer to update if a newer version is available
   await promptUpdate(await args._updateCheck);
 
-  // Done
   fmt.outro([
     'Install complete',
     '',
-    `  ${chalk.green('✓')} Source of truth: ~/.aw_registry/`,
+    `  ${chalk.green('✓')} Source of truth: ~/.aw/ (git clone)`,
+    `  ${chalk.green('✓')} Symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/`,
     `  ${chalk.green('✓')} IDE integration: ~/.claude/, ~/.cursor/, ~/.codex/`,
     hooksInstalled ? `  ${chalk.green('✓')} Git hooks: auto-sync on pull/clone (core.hooksPath)` : null,
     `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,

package/commands/nuke.mjs

@@ -290,7 +290,7 @@ export function nukeCommand(args) {
     } catch { /* not installed via npm or no permissions */ }
   }
 
-  // 10. Remove ~/.aw_registry/ itself (source of truth — last!)
+  // 10. Remove ~/.aw_registry/ — now a symlink to ~/.aw/.aw_registry/
   try {
     rmSync(GLOBAL_AW_DIR, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
   } catch {
@@ -298,6 +298,17 @@ export function nukeCommand(args) {
   }
   fmt.logStep('Removed ~/.aw_registry/');
 
+  // 11. Remove ~/.aw/ (persistent git clone)
+  const AW_HOME = join(HOME, '.aw');
+  if (existsSync(AW_HOME)) {
+    try {
+      rmSync(AW_HOME, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    } catch {
+      try { execSync(`rm -rf "${AW_HOME}"`, { stdio: 'pipe' }); } catch { /* best effort */ }
+    }
+    fmt.logStep('Removed ~/.aw/');
+  }
+
   fmt.outro([
     'Fully removed',
     '',
@@ -307,7 +318,7 @@ export function nukeCommand(args) {
     `  ${chalk.green('✓')} Project symlinks cleaned`,
     `  ${chalk.green('✓')} Git hooks removed`,
     `  ${chalk.green('✓')} IDE auto-sync tasks removed`,
-    `  ${chalk.green('✓')} Source of truth deleted`,
+    `  ${chalk.green('✓')} Source of truth deleted (symlink + git clone)`,
     '',
     `  ${chalk.dim('No existing files were touched.')}`,
     `  ${chalk.dim('To reinstall:')} ${chalk.bold('aw init')}`,