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

package/commands/drop.mjs

@@ -7,7 +7,7 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { resolveInput } from '../paths.mjs';
-import { removeFromSparseCheckout, isValidClone } from '../git.mjs';
+import { removeFromSparseCheckout, isValidClone, getLocalRegistryDir } from '../git.mjs';
 import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 
@@ -18,7 +18,7 @@ export function dropCommand(args) {
   const HOME = homedir();
   const AW_HOME = join(HOME, '.aw');
   const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
-  const workspaceDir = join(cwd, '.aw_registry');
+  const workspaceDir = getLocalRegistryDir(cwd, GLOBAL_AW_DIR);
 
   fmt.intro('aw drop');
 

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 } from 'node:path';
+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';
@@ -24,6 +23,8 @@ import {
   isValidClone,
   fetchAndMerge,
   addToSparseCheckout,
+  addProjectWorktree,
+  isWorktree,
   includeToSparsePaths,
   sparseCheckoutAsync,
   cleanup,
@@ -194,22 +195,40 @@ export async function initCommand(args) {
 
     const freshCfg = config.load(GLOBAL_AW_DIR);
 
-    linkWorkspace(HOME);
     await installAwEcc(cwd, { silent });
-    generateCommands(HOME);
     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();
 
-    if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
+    // 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 {
-        symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
-        if (!silent) fmt.logStep('Linked .aw_registry in current project');
+        addProjectWorktree(AW_HOME, cwd);
+        if (!silent) fmt.logStep('Linked current project as git worktree');
       } catch { /* best effort */ }
     }
 
+    // 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.
+    const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
+    const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
+    linkWorkspace(HOME, awDirForLinks);
+    generateCommands(HOME);
+
     if (silent) {
       autoUpdate(await args._updateCheck);
     } else {
@@ -218,7 +237,7 @@ export async function initCommand(args) {
         '',
         `  ${chalk.green('✓')} Registry updated`,
         `  ${chalk.green('✓')} IDE integration refreshed`,
-        cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Current project linked` : null,
+        cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Current project linked` : null,
       ].filter(Boolean).join('\n'));
     }
     return;
@@ -247,7 +266,7 @@ export async function initCommand(args) {
   }
 
   // Determine sparse paths
-  const sparsePaths = [`.aw_registry/platform`, `content`, `.aw_registry/AW-PROTOCOL.md`];
+  const sparsePaths = [`.aw_registry/platform`, `content`, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
   if (folderName) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
@@ -286,11 +305,8 @@ export async function initCommand(args) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
   }
 
-  // Step 3: Link IDE dirs + setup tasks
-  fmt.logStep('Linking IDE symlinks...');
-  linkWorkspace(HOME);
+  // Step 3: Setup tasks, MCP, hooks
   await installAwEcc(cwd, { silent });
-  generateCommands(HOME);
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
   const mcpFiles = await setupMcp(HOME, team) || [];
@@ -298,14 +314,34 @@ export async function initCommand(args) {
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
-  // Step 4: Symlink in current directory if it's a git repo
-  if (cwd !== HOME && !existsSync(join(cwd, '.aw_registry'))) {
+  // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
+  if (cwd !== HOME) {
+    const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
     try {
-      symlinkSync(GLOBAL_AW_DIR, join(cwd, '.aw_registry'));
-      fmt.logStep('Linked .aw_registry in current project');
+      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'))) {
+    try {
+      addProjectWorktree(AW_HOME, cwd);
+      fmt.logStep('Linked current project as git worktree');
     } catch { /* best effort */ }
   }
 
+  // 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 projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
+  const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
+  linkWorkspace(HOME, awDirForLinks);
+  generateCommands(HOME);
+
   // Offer to update if a newer version is available
   await promptUpdate(await args._updateCheck);
 
@@ -317,7 +353,7 @@ export async function initCommand(args) {
     `  ${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`,
-    cwd !== HOME && existsSync(join(cwd, '.aw_registry')) ? `  ${chalk.green('✓')} Linked in current project` : null,
+    cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Linked in current project` : null,
     '',
     `  ${chalk.dim('Existing repos:')} ${chalk.bold('cd <project> && aw link')}`,
     `  ${chalk.dim('New clones:')}     auto-linked via git hook`,

package/commands/link-project.mjs

@@ -1,26 +1,66 @@
-// commands/link-project.mjs — Symlink ~/.aw_registry into current project
+// commands/link-project.mjs — Link current project to registry via git worktree
 
-import { existsSync, symlinkSync } 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 { linkWorkspace } from '../link.mjs';
+import { generateCommands } from '../integrate.mjs';
 
-const GLOBAL_AW_DIR = join(homedir(), '.aw_registry');
+const HOME = homedir();
+const AW_HOME = join(HOME, '.aw');
 
 export function linkProjectCommand(args) {
   const cwd = process.cwd();
-  const target = join(cwd, '.aw_registry');
 
-  if (!existsSync(GLOBAL_AW_DIR)) {
-    fmt.cancel('No global install found. Run: aw init');
+  fmt.intro('aw link');
+
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  if (!isValidClone(AW_HOME, repoUrl)) {
+    fmt.cancel('Registry not initialized. Run: aw init');
+    return;
   }
 
-  if (existsSync(target)) {
-    fmt.logSuccess('.aw_registry already linked in this project');
+  if (cwd === HOME) {
+    fmt.cancel('Cannot link home directory as a project');
     return;
   }
 
-  symlinkSync(GLOBAL_AW_DIR, target);
-  fmt.logSuccess(`Linked .aw_registry → ~/.aw_registry/`);
+  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`);
+    return;
+  }
+
+  try {
+    addProjectWorktree(AW_HOME, cwd);
+    const projectRegistryDir = join(worktreeDir, REGISTRY_DIR);
+    const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
+    linkWorkspace(HOME, awDirForLinks);
+    generateCommands(HOME);
+    fmt.logSuccess([
+      `Linked project as git worktree`,
+      '',
+      `  ${chalk.green('✓')} ${chalk.dim('.aw/')}                  git worktree (IDE git panel enabled)`,
+      `  ${chalk.green('✓')} ${chalk.dim(`.aw/${REGISTRY_DIR}/`)} registry content`,
+      `  ${chalk.green('✓')} ${chalk.dim('.claude/.cursor/.codex/')} IDE symlinks wired`,
+    ].join('\n'));
+  } catch (e) {
+    fmt.cancel(`Failed to link project: ${e.message}`);
+  }
+
+  fmt.outro('Done');
 }

package/commands/nuke.mjs

@@ -10,6 +10,7 @@ import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { removeGlobalHooks } from '../hooks.mjs';
 import { uninstallAwEcc } from '../ecc.mjs';
+import { listProjectWorktrees } from '../git.mjs';
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
@@ -169,6 +170,25 @@ function removeProjectSymlinks() {
   }
 
   if (removed > 0) fmt.logStep(`Removed ${removed} project .aw_registry symlink${removed > 1 ? 's' : ''}`);
+
+  // Also remove legacy local .git/hooks/post-checkout installed by old aw versions
+  let hooksRemoved = 0;
+  try {
+    const result = execSync(
+      `find "${HOME}" -maxdepth 5 -path "*/.git/hooks/post-checkout" -type f 2>/dev/null`,
+      { encoding: 'utf8', timeout: 10000 }
+    ).trim();
+    for (const hookPath of result.split('\n').filter(Boolean)) {
+      try {
+        const content = readFileSync(hookPath, 'utf8');
+        if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+          unlinkSync(hookPath);
+          hooksRemoved++;
+        }
+      } catch { /* best effort */ }
+    }
+  } catch { /* find failed, skip */ }
+  if (hooksRemoved > 0) fmt.logStep(`Removed ${hooksRemoved} legacy .git/hooks/post-checkout script${hooksRemoved > 1 ? 's' : ''}`);
 }
 
 // 4. Remove git hooks (global core.hooksPath + legacy template)
@@ -298,8 +318,30 @@ export function nukeCommand(args) {
   }
   fmt.logStep('Removed ~/.aw_registry/');
 
-  // 11. Remove ~/.aw/ (persistent git clone)
+  // 11. Remove project git worktrees (must happen before deleting ~/.aw/)
   const AW_HOME = join(HOME, '.aw');
+  if (existsSync(AW_HOME)) {
+    try {
+      const worktrees = listProjectWorktrees(AW_HOME);
+      let wtRemoved = 0;
+      for (const wt of worktrees) {
+        try {
+          execSync(`git -C "${AW_HOME}" worktree remove "${wt.path}" --force`, { stdio: 'pipe' });
+          wtRemoved++;
+        } catch {
+          // Manual cleanup if git command fails
+          try { rmSync(wt.path, { recursive: true, force: true }); } catch { /* best effort */ }
+          wtRemoved++;
+        }
+      }
+      if (worktrees.length > 0) {
+        try { execSync(`git -C "${AW_HOME}" worktree prune`, { stdio: 'pipe' }); } catch { /* best effort */ }
+        fmt.logStep(`Removed ${wtRemoved} project worktree${wtRemoved > 1 ? 's' : ''}`);
+      }
+    } catch { /* best effort */ }
+  }
+
+  // 12. Remove ~/.aw/ (persistent git clone)
   if (existsSync(AW_HOME)) {
     try {
       rmSync(AW_HOME, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
@@ -315,6 +357,7 @@ export function nukeCommand(args) {
     `  ${chalk.green('✓')} Generated files cleaned`,
     `  ${chalk.green('✓')} IDE symlinks cleaned`,
     `  ${chalk.green('✓')} aw-ecc engine removed`,
+    `  ${chalk.green('✓')} Project worktrees removed`,
     `  ${chalk.green('✓')} Project symlinks cleaned`,
     `  ${chalk.green('✓')} Git hooks removed`,
     `  ${chalk.green('✓')} IDE auto-sync tasks removed`,

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 { fetchAndMerge, addToSparseCheckout, isValidClone } from '../git.mjs';
+import { fetchAndMerge, addToSparseCheckout, isValidClone, isWorktree, rebaseOntoOriginMain } from '../git.mjs';
 import { REGISTRY_DIR, REGISTRY_REPO, DOCS_SOURCE_DIR } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
@@ -73,18 +73,57 @@ export async function pullCommand(args) {
     log.logWarn(`Conflicts in: ${fetchResult.conflicts.join(', ')}`);
   }
 
+  // Always rebase project worktree's current branch onto origin/main
+  const localAw = join(cwd, '.aw');
+  if (cwd !== HOME && isWorktree(localAw)) {
+    try {
+      rebaseOntoOriginMain(localAw);
+      if (!silent) log.logStep('Local branch rebased onto latest');
+    } catch (e) {
+      // Check if the failure was due to merge conflicts
+      const isConflict = e.message?.includes('could not apply') || e.message?.includes('CONFLICT');
+      if (isConflict) {
+        // Get list of conflicted files
+        let conflictedFiles = [];
+        try {
+          const out = execSync(`git -C "${localAw}" diff --name-only --diff-filter=U`, {
+            stdio: 'pipe', encoding: 'utf8',
+          });
+          conflictedFiles = out.trim().split('\n').filter(Boolean);
+        } catch { /* best effort */ }
+
+        // Abort rebase to restore clean state
+        try {
+          execSync(`git -C "${localAw}" rebase --abort`, { stdio: 'pipe' });
+        } catch { /* best effort */ }
+
+        if (!silent) {
+          log.logWarn('Merge conflict detected — rebase aborted, your branch is unchanged.');
+          if (conflictedFiles.length > 0) {
+            log.logWarn(`Conflicting file${conflictedFiles.length > 1 ? 's' : ''}:`);
+            for (const f of conflictedFiles) log.logMessage(`  ${chalk.red('✗')} ${f}`);
+          }
+          log.logWarn('Resolve the conflict and run `aw pull` again, or check with `aw status`.');
+        }
+      } else {
+        const msg = e.message?.split('\n').find(l => l.trim()) ?? e.message;
+        if (!silent) log.logWarn(`Rebase skipped: ${msg}`);
+      }
+    }
+  }
+
   // Sync content/ → platform/docs/
   syncDocs(AW_HOME, GLOBAL_AW_DIR);
 
   // Re-link IDE dirs
   if (!args._skipIntegrate) {
-    linkWorkspace(HOME);
+    // 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.
+    const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
+    const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
+    linkWorkspace(HOME, awDirForLinks);
     generateCommands(HOME);
     copyInstructions(HOME, null, cfg.namespace);
-    if (cwd !== HOME) {
-      linkWorkspace(cwd);
-      generateCommands(cwd);
-    }
   }
 
   if (!silent) {