@ghl-ai/aw 0.1.36-beta.99 → 0.1.36

package/commands/pull.mjs

@@ -1,7 +1,7 @@
 // commands/pull.mjs — Pull content from registry using persistent git clone
 
-import { mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmdirSync, lstatSync } from 'node:fs';
-import { join, relative, extname } from 'node:path';
+import { existsSync, lstatSync } from 'node:fs';
+import { join, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { exec as execCb } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -11,7 +11,7 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { fetchAndMerge, addToSparseCheckout, removeFromSparseCheckout, syncWorktreeSparseCheckout, isValidClone, findNearestWorktree, rebaseOntoOriginMain } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, DOCS_SOURCE_DIR } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
 
@@ -74,14 +74,48 @@ export async function pullCommand(args) {
     }
   }
 
-  // Guard: if a rebase or merge is already in progress on awHome, don't proceed
+  // Guard: if a rebase or merge is already in progress on awHome, try to continue it.
   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;
+  const rebaseInProgress = existsSync(join(awGitDir, 'rebase-merge')) || existsSync(join(awGitDir, 'rebase-apply'));
+  const mergeInProgress = existsSync(join(awGitDir, 'MERGE_HEAD'));
+  if (rebaseInProgress || mergeInProgress) {
+    // Check for still-unresolved files (conflict markers present in index)
+    let unresolved = [];
+    try {
+      const { stdout } = await exec(`git -C "${AW_HOME}" diff --name-only --diff-filter=U`);
+      unresolved = stdout.trim().split('\n').filter(Boolean);
+    } catch { /* best effort */ }
+
+    if (unresolved.length > 0) {
+      // Still has conflicts — user needs to finish resolving
+      log.logWarn(`Rebase paused — resolve conflicts in your IDE, then run \`aw pull\` again.`);
+      if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
+      return;
+    }
+
+    // All conflicts resolved (files are staged) — continue the rebase automatically
+    try {
+      await exec(`git -C "${AW_HOME}" rebase --continue`, { env: { ...process.env, GIT_EDITOR: 'true' } });
+      log.logStep('Rebase continued after conflict resolution.');
+      // Force-push if on a push branch so origin stays in sync
+      const { stdout: branchOut } = await exec(`git -C "${AW_HOME}" rev-parse --abbrev-ref HEAD`);
+      const resumedBranch = branchOut.trim();
+      if (['upload/', 'remove/', 'sync/'].some(p => resumedBranch.startsWith(p))) {
+        try { await exec(`git -C "${AW_HOME}" push --force-with-lease origin "${resumedBranch}"`); } catch { /* non-blocking */ }
+      }
+    } catch {
+      // Could happen if there are more conflicting commits in the rebase sequence,
+      // or if the resolved changes result in an empty commit (skip it).
+      try {
+        await exec(`git -C "${AW_HOME}" rebase --skip`);
+        log.logStep('Empty commit skipped during rebase continuation.');
+      } catch {
+        log.logWarn('Rebase continuation failed — check `~/.aw` and resolve manually.');
+        if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
+        return;
+      }
+    }
+    // Fall through to re-link IDE dirs after successful rebase continuation
   }
 
   // Fetch + merge latest
@@ -89,7 +123,7 @@ export async function pullCommand(args) {
   s.start('Fetching latest from registry...');
   let fetchResult = { updated: false, conflicts: [] };
   try {
-    fetchResult = await fetchAndMerge(AW_HOME);
+    fetchResult = await fetchAndMerge(AW_HOME, { silent });
     s.stop(fetchResult.updated ? 'Registry updated' : 'Already up to date');
   } catch (e) {
     s.stop(chalk.yellow('Fetch failed'));
@@ -113,13 +147,13 @@ 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 */ }
+      // Interactive mode: rebase is paused with conflict markers in the working tree.
+      // Leave it for the user to resolve in their IDE, then re-run `aw pull`.
       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
+    // Silent mode: rebase was already aborted in fetchAndMerge; just report.
     log.logWarn(`Conflicts in: ${fetchResult.conflicts.join(', ')}`);
   }
 
@@ -169,9 +203,6 @@ export async function pullCommand(args) {
     }
   }
 
-  // Sync content/ → platform/docs/
-  syncDocs(AW_HOME, GLOBAL_AW_DIR);
-
   // Re-link IDE dirs
   if (!args._skipIntegrate) {
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
@@ -198,16 +229,6 @@ export async function pullCommand(args) {
   }
 }
 
-/**
- * Sync ~/.aw/content/ markdown files → ~/.aw_registry/platform/docs/
- */
-function syncDocs(awHome, globalAwDir) {
-  const contentSrc = join(awHome, DOCS_SOURCE_DIR);
-  if (!existsSync(contentSrc)) return;
-  const docsDest = join(globalAwDir, 'platform', 'docs');
-  syncMarkdownTree(contentSrc, docsDest);
-}
-
 /**
  * pullAsync — kept for backward compat; now delegates to pullCommand.
  */
@@ -216,58 +237,6 @@ export async function pullAsync(args) {
   return { pattern: args._positional?.[0] || '', actions: [], conflictCount: 0 };
 }
 
-/**
- * Collect all .md file paths (relative) in a directory tree.
- */
-function collectMarkdownPaths(dir, base) {
-  const paths = new Set();
-  if (!existsSync(dir)) return paths;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith('.')) continue;
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      for (const p of collectMarkdownPaths(full, base)) paths.add(p);
-    } else if (entry.name.endsWith('.md')) {
-      paths.add(relative(base, full));
-    }
-  }
-  return paths;
-}
-
-/**
- * Sync .md files from src to dest: copy new/changed, delete removed, prune empty dirs.
- */
-function syncMarkdownTree(src, dest) {
-  mkdirSync(dest, { recursive: true });
-
-  const remotePaths = collectMarkdownPaths(src, src);
-  const localPaths = collectMarkdownPaths(dest, dest);
-
-  for (const rel of remotePaths) {
-    const srcPath = join(src, rel);
-    const destPath = join(dest, rel);
-    mkdirSync(join(dest, rel, '..'), { recursive: true });
-    copyFileSync(srcPath, destPath);
-  }
-
-  for (const rel of localPaths) {
-    if (!remotePaths.has(rel)) {
-      const destPath = join(dest, rel);
-      try { unlinkSync(destPath); } catch { /* best effort */ }
-    }
-  }
-
-  function pruneEmpty(dir) {
-    if (!existsSync(dir)) return;
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory()) pruneEmpty(join(dir, entry.name));
-    }
-    try {
-      if (readdirSync(dir).length === 0 && dir !== dest) rmdirSync(dir);
-    } catch { /* best effort */ }
-  }
-  pruneEmpty(dest);
-}
 
 function registerMcp(namespace) {
   const mcpUrl = process.env.GHL_MCP_URL;

package/commands/push.mjs

@@ -319,7 +319,7 @@ async function createOrUpdatePR(awHome, branch, prTitle, prBody) {
 //   - Always creates a new branch from current state, commits, pushes, stays there.
 //   - Every aw push = one new branch + one new PR. No force-push, no reuse.
 // Global flow (worktreeFlow=false): same but returns to main after push.
-async function doPush(files, awHome, dryRun, worktreeFlow = false, preStaged = false) {
+async function doPush(files, awHome, dryRun, worktreeFlow = false, preStaged = false, extraPaths = []) {
   const added = files.filter(f => !f.deleted);
   const deleted = files.filter(f => f.deleted);
 
@@ -369,6 +369,10 @@ async function doPush(files, awHome, dryRun, worktreeFlow = false, preStaged = f
   if (newNamespaces.length > 0 && existsSync(codeownersPath)) {
     pathsToStage.push('CODEOWNERS');
   }
+  // Also stage any extra paths (content/, CODEOWNERS manual edits) passed from the caller
+  for (const p of extraPaths) {
+    if (!pathsToStage.includes(p)) pathsToStage.push(p);
+  }
 
   const commitMsg = generateCommitMsg(files);
   const prTitle = generatePrTitle(files, awHome);
@@ -449,10 +453,31 @@ export async function pushCommand(args) {
 
   // No args = staged files first (git commit behaviour), else auto-detect all changes
   if (!input) {
+    // Extra paths outside .aw_registry/ that aw also manages: content/ and CODEOWNERS.
+    // Detect staged variants for staged-mode and unstaged variants for auto-mode.
+    const getExtraStagedPaths = async () => {
+      try {
+        const { stdout } = await exec(`git -C "${awHome}" diff --cached --name-only -- content/ CODEOWNERS`);
+        return stdout.trim().split('\n').filter(Boolean);
+      } catch { return []; }
+    };
+    const getExtraChangedPaths = async () => {
+      try {
+        const { stdout } = await exec(`git -C "${awHome}" status --porcelain -- content/ CODEOWNERS`);
+        // git status --porcelain prefix is XY (2 chars) + optional space + path.
+        // Staged-only files: `M path` (2-char prefix); unstaged files: ` M path` (3-char prefix).
+        // slice(2).trimStart() handles both cases correctly.
+        return stdout.trim().split('\n').filter(Boolean)
+          .map(l => l.slice(2).trimStart())
+          .filter(Boolean);
+      } catch { return []; }
+    };
+
     // ── Staged mode: use whatever is in the index ──────────────────────
     const staged = getStagedFiles(awHome, REGISTRY_DIR);
+    const extraStaged = await getExtraStagedPaths();
 
-    if (staged.length > 0) {
+    if (staged.length > 0 || extraStaged.length > 0) {
       const files = staged.map(f => {
         const meta = parseRegistryPath(f.registryPath);
         const parts = f.registryPath.split('/');
@@ -465,26 +490,28 @@ export async function pushCommand(args) {
           deleted: f.deleted,
         };
       });
-      fmt.logInfo(`${chalk.dim('mode:')} staged (${files.length} file${files.length > 1 ? 's' : ''})`);
-      await doPush(files, awHome, dryRun, worktreeFlow, true);
+      const totalCount = files.length + extraStaged.length;
+      fmt.logInfo(`${chalk.dim('mode:')} staged (${totalCount} file${totalCount > 1 ? 's' : ''})`);
+      await doPush(files, awHome, dryRun, worktreeFlow, true, extraStaged);
       return;
     }
 
     // ── Auto mode: stage all changes in .aw_registry/ ─────────────────
     const changes = detectChanges(awHome, REGISTRY_DIR);
+    const extraChanged = await getExtraChangedPaths();
     const allEntries = [
       ...changes.modified.map(e => ({ ...e, deleted: false })),
       ...changes.untracked.map(e => ({ ...e, deleted: false })),
       ...changes.deleted.map(e => ({ ...e, deleted: true })),
     ];
 
-    if (allEntries.length === 0 && commitsAheadOfMain(awHome) > 0) {
+    if (allEntries.length === 0 && extraChanged.length === 0 && commitsAheadOfMain(awHome) > 0) {
       fmt.logInfo(`${chalk.dim('mode:')} auto (no new changes — branching current state)`);
       await doPush([], awHome, dryRun, worktreeFlow, false);
       return;
     }
 
-    if (allEntries.length === 0) {
+    if (allEntries.length === 0 && extraChanged.length === 0) {
       fmt.cancel('Nothing to push — no staged or modified files.\n\n  Stage files in your IDE or use `aw status` to see changes.');
       return;
     }
@@ -503,7 +530,7 @@ export async function pushCommand(args) {
         };
       });
 
-    if (files.length === 0) {
+    if (files.length === 0 && extraChanged.length === 0) {
       if (commitsAheadOfMain(awHome) > 0) {
         fmt.logInfo(`${chalk.dim('mode:')} auto (no new changes — branching current state)`);
         await doPush([], awHome, dryRun, worktreeFlow, false);
@@ -513,8 +540,9 @@ export async function pushCommand(args) {
       return;
     }
 
-    fmt.logInfo(`${chalk.dim('mode:')} auto (${files.length} file${files.length > 1 ? 's' : ''} — stage specific files to push a subset)`);
-    await doPush(files, awHome, dryRun, worktreeFlow, false);
+    const totalCount = files.length + extraChanged.length;
+    fmt.logInfo(`${chalk.dim('mode:')} auto (${totalCount} file${totalCount > 1 ? 's' : ''} — stage specific files to push a subset)`);
+    await doPush(files, awHome, dryRun, worktreeFlow, false, extraChanged);
     return;
   }
 

package/constants.mjs

@@ -4,7 +4,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 /** Base branch for PRs and sync checkout */
-export const REGISTRY_BASE_BRANCH = process.env.AW_REGISTRY_BASE_BRANCH || 'chore/stream-registry';
+export const REGISTRY_BASE_BRANCH = process.env.AW_REGISTRY_BASE_BRANCH || 'main';
 
 /** Default registry repository */
 export const REGISTRY_REPO = 'GoHighLevel/platform-docs';

package/git.mjs

@@ -293,22 +293,30 @@ export async function fetchAndMerge(awHome, { silent = true } = {}) {
   let updated = false;
   const conflicts = [];
 
-  // ── 3. Fast-forward (no local commits ahead of remote) ───────────────────
-  try {
-    const { stdout } = await exec(
-      `git -C "${awHome}" merge origin/${REGISTRY_BASE_BRANCH} --ff-only`,
-    );
-    updated = !stdout.includes('Already up to date');
-    return { updated, conflicts };
-  } catch { /* local commits exist — fall through to rebase */ }
-
-  // ── 4. Rebase current branch onto remote REGISTRY_BASE_BRANCH ────────────
-  // For push branches: stacks our local commits on top of latest remote.
-  // For base branch:   only reached if local commits exist (unusual).
-  // Never uses --no-edit merge — that disables sparse checkout on blob:none.
+  // ── 3 + 4. Rebase onto remote REGISTRY_BASE_BRANCH ──────────────────────
+  // Handles both cases in one path:
+  //  • No local commits (base branch, clean tree) → fast-forward via rebase
+  //  • Local commits (push branch)                → rebases on top
+  //  • Uncommitted local changes                  → rebase refuses to run,
+  //    sync is skipped this run, changes are preserved
+  //
+  // We avoid `merge --ff-only` and `merge --no-edit` entirely: both trigger a
+  // git 2.46+ bug on blob:none + no-cone sparse-checkout repos that silently
+  // drops bare-name patterns (e.g. "content", "CODEOWNERS") when HEAD advances.
   try {
     await exec(`git -C "${awHome}" rebase origin/${REGISTRY_BASE_BRANCH}`);
     updated = true;
+    // Push branch rebase rewrites commit SHAs — force-push so origin/upload/...
+    // stays in sync with the rebased local branch.  Without this, VS Code and
+    // plain `git pull` show a false divergence ("2↑ 1↓") that can't be resolved
+    // without specifying a reconcile strategy.
+    // --force-with-lease is safer than --force: it refuses to overwrite if
+    // someone else pushed to the remote tracking branch since our last fetch.
+    if (isPushBranch) {
+      try {
+        await exec(`git -C "${awHome}" push --force-with-lease origin "${currentBranch}"`);
+      } catch { /* non-blocking — divergence will be resolved on next aw push */ }
+    }
   } catch {
     try {
       const { stdout } = await exec(`git -C "${awHome}" diff --name-only --diff-filter=U`);

package/hooks.mjs

@@ -51,15 +51,21 @@ exit 0
 
 const POST_MERGE = makeDispatcher('post-merge', `\
 if command -v aw >/dev/null 2>&1; then
-  aw init --silent >/dev/null 2>&1 &
+  # Unset ALL git env vars so aw's "git -C ~/.aw" runs against the correct repo,
+  # not the project repo that triggered this hook. Using git's own list of
+  # local env vars is more robust than hardcoding specific names.
+  unset $(git rev-parse --local-env-vars 2>/dev/null)
+  aw pull --silent >/dev/null 2>&1 &
 fi`);
 
 const POST_CHECKOUT = makeDispatcher('post-checkout', `\
+# Unset ALL git env vars so aw's "git -C ~/.aw" runs against the correct repo.
+unset $(git rev-parse --local-env-vars 2>/dev/null)
 if [ -d "$HOME/.aw" ] && [ ! -d ".aw" ] && [ -d ".git" ] && command -v aw >/dev/null 2>&1; then
   aw link >/dev/null 2>&1 &
 fi
 if command -v aw >/dev/null 2>&1; then
-  aw init --silent >/dev/null 2>&1 &
+  aw pull --silent >/dev/null 2>&1 &
 fi`);
 
 // post-commit: written separately — needs different guard logic than other hooks.
@@ -68,6 +74,9 @@ fi`);
 const POST_COMMIT = `#!/bin/sh
 # aw: global post-commit dispatcher (installed by aw init)
 
+# Unset ALL git env vars so aw's "git -C ~/.aw" runs against the correct repo.
+unset $(git rev-parse --local-env-vars 2>/dev/null)
+
 # Skip temp sparse checkouts
 case "$(pwd)" in /tmp/aw-*|/var/folders/*/aw-*) exit 0 ;; esac
 

package/mcp.mjs

@@ -297,10 +297,16 @@ export async function setupMcp(cwd, namespace, { silent = false } = {}) {
   }
 
   // ── Codex: ~/.codex/config.toml (TOML format) ──
+  // Also merge into the ECC source file (~/.aw-ecc/.codex/config.toml) so
+  // that when installAwEcc re-copies it on subsequent inits the ghl-ai entry
+  // survives — without this, each re-init overwrites ~/.codex/config.toml
+  // from the ECC source which doesn't have the ghl-ai block.
   const codexTomlPath = join(HOME, '.codex', 'config.toml');
   if (mergeTomlMcpServer(codexTomlPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(codexTomlPath);
   }
+  const eccCodexTomlPath = join(HOME, '.aw-ecc', '.codex', 'config.toml');
+  mergeTomlMcpServer(eccCodexTomlPath, 'ghl-ai', ghlAiServerLocal);
 
   // Deduplicate
   const unique = [...new Set(updatedFiles)];

package/package.json

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