@ghl-ai/aw 0.1.36-beta.71 → 0.1.36-beta.73

package/commands/pull.mjs

@@ -1,6 +1,6 @@
 // commands/pull.mjs — Pull content from registry using persistent git clone
 
-import { mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmdirSync } from 'node:fs';
+import { mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmdirSync, lstatSync } from 'node:fs';
 import { join, relative, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { exec as execCb } from 'node:child_process';
@@ -74,6 +74,16 @@ export async function pullCommand(args) {
     }
   }
 
+  // Guard: if a rebase or merge is already in progress on awHome, don't proceed
+  const awGitDir = join(AW_HOME, '.git');
+  if (existsSync(join(awGitDir, 'rebase-merge')) ||
+      existsSync(join(awGitDir, 'rebase-apply')) ||
+      existsSync(join(awGitDir, 'MERGE_HEAD'))) {
+    log.logWarn('Rebase paused — resolve conflicts in your IDE, then run `aw pull` again.');
+    if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
+    return;
+  }
+
   // Fetch + merge latest
   const s = log.spinner();
   s.start('Fetching latest from registry...');
@@ -102,12 +112,26 @@ export async function pullCommand(args) {
   }
 
   if (fetchResult.conflicts.length > 0) {
+    if (!silent) {
+      // Interactive mode: abort the merge so the working tree is clean again
+      try { await exec(`git -C "${AW_HOME}" merge --abort`); } catch { /* best effort */ }
+      log.logWarn(`Merge conflict in: ${fetchResult.conflicts.join(', ')}`);
+      log.logWarn('Merge aborted — your branch is unchanged. Resolve conflicts and run `aw pull` again.');
+      return;
+    }
+    // Silent mode: leave conflict markers in place for IDE to show
     log.logWarn(`Conflicts in: ${fetchResult.conflicts.join(', ')}`);
   }
 
-  // Always rebase project worktree's current branch onto origin/main
+  // Rebase project worktree branch onto origin/main — only for legacy git worktrees.
+  // In the symlink model, <project>/.aw IS ~/.aw (same repo), so fetchAndMerge already
+  // brought it up to date. Nothing to rebase.
   const localAw = cwd !== HOME ? findNearestWorktree(cwd, HOME) : null;
+  let isSymlinkWorktree = false;
   if (localAw) {
+    try { isSymlinkWorktree = lstatSync(localAw).isSymbolicLink(); } catch {}
+  }
+  if (localAw && !isSymlinkWorktree) {
     const rebaseSpinner = log.spinner();
     rebaseSpinner.start('Rebasing local branch onto latest...');
     try {
@@ -129,9 +153,7 @@ export async function pullCommand(args) {
         } catch { /* best effort */ }
 
         if (!silent) {
-          // Interactive mode: abort and show clear terminal warning
           try { await exec(`git -C "${localAw}" rebase --abort`); } catch { /* best effort */ }
-
           log.logWarn('Rebase aborted — your branch is unchanged.');
           if (conflictedFiles.length > 0) {
             log.logWarn(`Conflicting file${conflictedFiles.length > 1 ? 's' : ''}:`);

package/commands/push.mjs

@@ -427,15 +427,14 @@ export async function pushCommand(args) {
   const HOME = homedir();
   const globalAw = join(HOME, '.aw');
 
-  // If the project has a local worktree (.aw/ with a .git file), use it so
-  // changes made inside the project are correctly detected and committed.
-  const localAw = findNearestWorktree(cwd, HOME);
-  const hasWorktree = localAw !== null;
-  const awHome = hasWorktree ? localAw : globalAw;
+  // Always push from the global clone (~/.aw), same as aw pull.
+  // All agent/skill edits via IDE symlinks land in ~/.aw/.aw_registry/ directly —
+  // project worktrees are just local views for IDE visibility, not the source of truth.
+  const awHome = globalAw;
   const registrySubDir = join(awHome, REGISTRY_DIR);
   const workspaceDir = getLocalRegistryDir(cwd, join(HOME, '.aw_registry'));
 
-  const worktreeFlow = hasWorktree;
+  const worktreeFlow = false;
 
   fmt.intro('aw push');
 

package/commands/status.mjs

@@ -5,7 +5,7 @@ import { homedir } from 'node:os';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { detectChanges, getCurrentBranch, commitsAheadOfMain, isValidClone, findNearestWorktree } from '../git.mjs';
+import { detectChanges, diffFromMain, getCurrentBranch, commitsAheadOfMain, isValidClone, findNearestWorktree } from '../git.mjs';
 import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL } from '../constants.mjs';
 
 export function statusCommand(args) {
@@ -51,54 +51,64 @@ export function statusCommand(args) {
     fmt.logInfo('No extra paths synced (platform/ always included).');
   }
 
-  // Git-native change detection
-  const changes = detectChanges(AW_HOME, REGISTRY_DIR);
+  // ── Drift from main (3-dot diff: captures committed+pushed changes too) ────
+  const drift = diffFromMain(AW_HOME, REGISTRY_DIR);
+  const driftTotal = drift.added.length + drift.modified.length + drift.deleted.length;
 
-  const { modified, added, deleted, untracked } = changes;
-  const allNew = [...added, ...untracked];
-
-  // Summary line
-  const summaryParts = [
-    modified.length > 0 ? chalk.yellow(`${modified.length} modified`) : null,
-    allNew.length > 0 ? chalk.green(`${allNew.length} new (unpushed)`) : null,
-    deleted.length > 0 ? chalk.dim(`${deleted.length} deleted`) : null,
+  const driftParts = [
+    drift.added.length > 0 ? chalk.green(`${drift.added.length} added`) : null,
+    drift.modified.length > 0 ? chalk.yellow(`${drift.modified.length} modified`) : null,
+    drift.deleted.length > 0 ? chalk.dim(`${drift.deleted.length} deleted`) : null,
   ].filter(Boolean);
 
-  if (summaryParts.length === 0) {
-    fmt.logSuccess('Workspace is clean');
+  if (driftTotal === 0) {
+    fmt.logSuccess('No drift from main — workspace is in sync');
   } else {
-    fmt.logInfo(summaryParts.join(chalk.dim(' · ')));
+    fmt.logInfo(`Drift from main: ${driftParts.join(chalk.dim(' · '))}`);
   }
 
-  if (allNew.length > 0) {
+  if (drift.added.length > 0) {
     fmt.note(
-      allNew.map(f => chalk.green(`  ${f.registryPath}`)).join('\n'),
-      chalk.green('New (unpushed)')
+      drift.added.map(f => chalk.green(`  + ${f.registryPath}`)).join('\n'),
+      chalk.green('Added (vs main)')
     );
   }
 
-  if (modified.length > 0) {
+  if (drift.modified.length > 0) {
     fmt.note(
-      modified.map(f => chalk.yellow(`  ${f.registryPath}`)).join('\n'),
-      chalk.yellow('Modified')
+      drift.modified.map(f => chalk.yellow(`  ~ ${f.registryPath}`)).join('\n'),
+      chalk.yellow('Modified (vs main)')
     );
   }
 
-  if (deleted.length > 0) {
+  if (drift.deleted.length > 0) {
     fmt.note(
-      deleted.map(f => chalk.dim(`  ${f.registryPath}`)).join('\n'),
-      chalk.dim('Deleted')
+      drift.deleted.map(f => chalk.dim(`  - ${f.registryPath}`)).join('\n'),
+      chalk.dim('Deleted (vs main)')
     );
   }
 
+  // ── Uncommitted local changes (on top of drift) ───────────────────────────
+  const local = detectChanges(AW_HOME, REGISTRY_DIR);
+  const localDirty = [...local.modified, ...local.added, ...local.deleted, ...local.untracked];
+
+  if (localDirty.length > 0) {
+    const localParts = [
+      (local.modified.length > 0) ? chalk.yellow(`${local.modified.length} modified`) : null,
+      (local.added.length + local.untracked.length > 0) ? chalk.green(`${local.added.length + local.untracked.length} new`) : null,
+      (local.deleted.length > 0) ? chalk.dim(`${local.deleted.length} deleted`) : null,
+    ].filter(Boolean);
+    fmt.logWarn(`Uncommitted local changes: ${localParts.join(chalk.dim(' · '))} — run ${chalk.dim('aw push')} to commit & open PR`);
+  }
+
   if (!isOnMain) {
     const ahead = commitsAheadOfMain(AW_HOME);
-    const aheadStr = ahead > 0 ? ` (${chalk.yellow(`${ahead} commit${ahead !== 1 ? 's' : ''} ahead`)})` : '';
+    const aheadStr = ahead > 0 ? ` (${chalk.yellow(`${ahead} commit${ahead !== 1 ? 's' : ''} ahead of main`)})` : '';
     fmt.logWarn(`On branch ${chalk.yellow(branch)}${aheadStr} — run ${chalk.dim('aw push')} to open a PR or ${chalk.dim('aw pull')} to sync`);
   }
 
   // Hints
-  if (allNew.length > 0 || modified.length > 0 || deleted.length > 0) {
+  if (driftTotal > 0 || localDirty.length > 0) {
     fmt.logInfo(`Push changes: ${chalk.dim('aw push')} or ${chalk.dim('aw push <path>')}`);
   }
 

package/git.mjs

@@ -1,7 +1,7 @@
 // git.mjs — Git helpers: sparse checkout (temp) + persistent clone operations.
 
 import { execSync, exec as execCb } from 'node:child_process';
-import { mkdtempSync, existsSync, lstatSync, rmSync, readFileSync } from 'node:fs';
+import { mkdtempSync, existsSync, lstatSync, rmSync, readFileSync, symlinkSync, unlinkSync } from 'node:fs';
 import { join, basename, dirname } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { promisify } from 'node:util';
@@ -172,6 +172,8 @@ export function addToSparseCheckout(awHome, newPaths) {
  * Called after `addToSparseCheckout` so newly-pulled content appears in project/.aw/.
  */
 export function syncWorktreeSparseCheckout(awHome, worktreeDir) {
+  // Symlink model: worktreeDir IS awHome — sparse checkout is already shared, nothing to sync
+  try { if (lstatSync(worktreeDir).isSymbolicLink()) return; } catch { return; }
   try {
     const out = execSync('git sparse-checkout list', { cwd: awHome, stdio: 'pipe', encoding: 'utf8' });
     const paths = out.trim().split('\n').filter(Boolean);
@@ -323,7 +325,7 @@ export function commitToCurrentBranch(awHome, files, commitMsg, preStaged = fals
   if (!preStaged) {
     try {
       const quotedFiles = files.map(f => `"${f}"`).join(' ');
-      execSync(`git -C "${awHome}" add --sparse ${quotedFiles}`, { stdio: 'pipe' });
+      execSync(`git -C "${awHome}" add ${quotedFiles}`, { stdio: 'pipe' });
     } catch (e) {
       throw new Error(`Failed to stage files: ${e.message}`);
     }
@@ -379,7 +381,7 @@ export async function createPushBranch(awHome, branchName, files, commitMsg, pre
     if (!preStaged) {
       try {
         const quotedFiles = files.map(f => `"${f}"`).join(' ');
-        await exec(`git -C "${awHome}" add --sparse ${quotedFiles}`);
+        await exec(`git -C "${awHome}" add ${quotedFiles}`);
       } catch (e) {
         throw new Error(`Failed to stage files: ${e.message}`);
       }
@@ -416,6 +418,42 @@ export function commitsAheadOfMain(awHome) {
   }
 }
 
+/**
+ * Get all files that differ from origin/main (or local main as fallback).
+ * Uses 3-dot diff (origin/main...HEAD) so it captures the full branch delta —
+ * including commits already pushed — not just uncommitted working-tree changes.
+ *
+ * Returns { added: [], modified: [], deleted: [] }
+ * Each entry: { path: 'relative/to/awHome', registryPath: 'relative/to/registryDir' }
+ */
+export function diffFromMain(awHome, registryDir) {
+  for (const base of [`origin/${REGISTRY_BASE_BRANCH}`, REGISTRY_BASE_BRANCH]) {
+    try {
+      const out = execSync(
+        `git -C "${awHome}" diff ${base}...HEAD --name-status -- "${registryDir}/"`,
+        { stdio: 'pipe', encoding: 'utf8' },
+      );
+      const added = [], modified = [], deleted = [];
+      for (const line of out.trim().split('\n')) {
+        if (!line) continue;
+        const [status, filePath] = line.split('\t');
+        if (!filePath) continue;
+        const registryPath = filePath.startsWith(registryDir + '/')
+          ? filePath.slice(registryDir.length + 1)
+          : filePath;
+        const entry = { path: filePath, registryPath };
+        if (status === 'A') added.push(entry);
+        else if (status === 'D') deleted.push(entry);
+        else modified.push(entry); // M, R*, C*, T
+      }
+      return { added, modified, deleted };
+    } catch {
+      continue; // try next base ref
+    }
+  }
+  return { added: [], modified: [], deleted: [] };
+}
+
 /**
  * Get one-line log of commits ahead of main.
  * Returns array of { hash, message } objects.
@@ -510,9 +548,17 @@ export function findNearestWorktree(startDir, stopDir) {
 }
 
 /**
- * Check if dir is a git linked worktree (has .git as a FILE, not a directory).
+ * Check if dir is a valid project .aw/ link — either:
+ *   (a) a symlink to awHome  (new model — one shared repo for all workspaces), or
+ *   (b) a legacy git linked worktree (.git is a FILE pointing to a valid gitdir).
  */
 export function isWorktree(dir) {
+  // (a) symlink model: <project>/.aw → ~/.aw
+  try {
+    if (lstatSync(dir).isSymbolicLink() && existsSync(dir)) return true;
+  } catch { /* doesn't exist */ }
+
+  // (b) legacy git worktree model
   const gitPath = join(dir, '.git');
   try {
     if (!lstatSync(gitPath).isFile()) return false;
@@ -527,11 +573,13 @@ export function isWorktree(dir) {
 }
 
 /**
- * Create project/.aw/ as a linked git worktree of awHome.
- * Sets up sparse checkout mirroring the main clone, then creates
- * project/.aw_registry → project/.aw/.aw_registry/ (relative symlink).
+ * Create project/.aw/ as a symlink to awHome (~/.aw).
  *
- * Safe to call multiple times — skips if already set up.
+ * All IDE workspaces share the exact same git repo via this symlink — same
+ * branch, same content, always in sync. aw pull/push both operate on awHome
+ * directly, so there are no per-project diverging branches.
+ *
+ * Safe to call multiple times — skips if already set up correctly.
  */
 export function addProjectWorktree(awHome, projectDir) {
   const worktreeDir = join(projectDir, '.aw');
@@ -542,89 +590,47 @@ export function addProjectWorktree(awHome, projectDir) {
     if (lstatSync(staleSymlink).isSymbolicLink()) rmSync(staleSymlink);
   } catch { /* doesn't exist, fine */ }
 
-  // Already set up and healthy
-  if (isWorktree(worktreeDir)) return worktreeDir;
-
-  // Stale .aw/ exists (broken git link — e.g. after aw nuke + re-init) — remove so git can recreate it
-  if (existsSync(worktreeDir)) {
-    try { execSync(`rm -rf "${worktreeDir}"`, { stdio: 'pipe' }); } catch { /* best effort */ }
-  }
-
-  // Prune stale worktree metadata from ~/.aw/.git/worktrees/ before re-adding.
-  // Without this, `git worktree add` fails because the old metadata entry may still
-  // reference the deleted path, causing a "already exists" or similar error.
-  try { execSync(`git -C "${awHome}" worktree prune`, { stdio: 'pipe' }); } catch { /* best effort */ }
-
-  const slug = basename(projectDir)
-    .toLowerCase()
-    .replace(/[^a-z0-9]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '')
-    .slice(0, 40) || 'project';
-  const branchName = `worktree/${slug}`;
-
-  // Try to create the worktree with a new branch
-  let created = false;
+  // Already a valid symlink pointing to awHome → done
   try {
-    execSync(`git -C "${awHome}" worktree add "${worktreeDir}" --no-checkout -b "${branchName}"`, { stdio: 'pipe' });
-    created = true;
-  } catch {
-    // Branch already exists from a previous setup — reuse it
-    try {
-      execSync(`git -C "${awHome}" worktree add "${worktreeDir}" --no-checkout "${branchName}"`, { stdio: 'pipe' });
-      created = true;
-    } catch {
-      // Last resort: unique branch name
-      const unique = `${branchName}-${Date.now().toString(36).slice(-4)}`;
-      execSync(`git -C "${awHome}" worktree add "${worktreeDir}" --no-checkout -b "${unique}"`, { stdio: 'pipe' });
-      created = true;
-    }
-  }
+    if (lstatSync(worktreeDir).isSymbolicLink() && existsSync(worktreeDir)) return worktreeDir;
+  } catch { /* doesn't exist yet */ }
 
-  if (!created) throw new Error(`Failed to create worktree at ${worktreeDir}`);
-
-  // Set up sparse checkout in the worktree, mirroring the main clone's paths
+  // Remove old git worktree or stale directory/symlink so we can create a clean symlink
   try {
-    execSync(`git -C "${worktreeDir}" sparse-checkout init --no-cone`, { stdio: 'pipe' });
-
-    let sparsePaths = [];
-    try {
-      const out = execSync('git sparse-checkout list', { cwd: awHome, stdio: 'pipe', encoding: 'utf8' });
-      sparsePaths = out.trim().split('\n').filter(Boolean);
-    } catch { /* fallback below */ }
-
-    if (sparsePaths.length === 0) {
-      sparsePaths = [`${REGISTRY_DIR}/platform`, 'content', 'CODEOWNERS'];
+    const stat = lstatSync(worktreeDir);
+    if (stat.isSymbolicLink()) {
+      unlinkSync(worktreeDir); // dangling symlink — replace
+    } else if (stat.isDirectory()) {
+      // Legacy git worktree — detach from git before removing
+      try { execSync(`git -C "${awHome}" worktree remove "${worktreeDir}" --force`, { stdio: 'pipe' }); } catch {}
+      try { execSync(`git -C "${awHome}" worktree prune`, { stdio: 'pipe' }); } catch {}
+      rmSync(worktreeDir, { recursive: true, force: true });
     }
+  } catch { /* nothing there — fine */ }
 
-    execSync(`git -C "${worktreeDir}" sparse-checkout set ${sparsePaths.map(p => `"${p}"`).join(' ')}`, { stdio: 'pipe' });
-    execSync(`git -C "${worktreeDir}" checkout`, { stdio: 'pipe' });
-  } catch (e) {
-    throw new Error(`Failed to configure worktree sparse checkout: ${e.message}`);
-  }
-
+  // Create symlink: <project>/.aw → ~/.aw
+  symlinkSync(awHome, worktreeDir);
   return worktreeDir;
 }
 
 /**
- * Remove a project worktree created by addProjectWorktree.
- * Removes the worktree directory and the .aw_registry symlink.
+ * Remove a project .aw/ link created by addProjectWorktree.
+ * For the new symlink model: just removes the symlink (never the target ~/.aw).
+ * For legacy git worktrees: removes via git worktree remove.
  */
 export function removeProjectWorktree(awHome, projectDir) {
   const worktreeDir = join(projectDir, '.aw');
-
-  // Remove via git first
   try {
-    execSync(`git -C "${awHome}" worktree remove "${worktreeDir}" --force`, { stdio: 'pipe' });
-  } catch {
-    // Manual cleanup if git command fails
-    try {
-      if (existsSync(worktreeDir)) {
-        rmSync(worktreeDir, { recursive: true, force: true });
-      }
-    } catch { /* best effort */ }
-    try { execSync(`git -C "${awHome}" worktree prune`, { stdio: 'pipe' }); } catch { /* best effort */ }
-  }
+    const stat = lstatSync(worktreeDir);
+    if (stat.isSymbolicLink()) {
+      unlinkSync(worktreeDir); // remove symlink only — never delete ~/.aw
+    } else if (stat.isDirectory()) {
+      // Legacy git worktree
+      try { execSync(`git -C "${awHome}" worktree remove "${worktreeDir}" --force`, { stdio: 'pipe' }); } catch {}
+      try { rmSync(worktreeDir, { recursive: true, force: true }); } catch {}
+      try { execSync(`git -C "${awHome}" worktree prune`, { stdio: 'pipe' }); } catch {}
+    }
+  } catch { /* doesn't exist — nothing to do */ }
 }
 
 /**

package/package.json

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