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

package/commands/status.mjs

@@ -1,130 +1,100 @@
-// commands/status.mjs — Show workspace status
+// commands/status.mjs — Show workspace status using native git
 
 import { join } from 'node:path';
-import { existsSync, readFileSync } 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 { load as loadManifest } from '../manifest.mjs';
-import { hashFile } from '../registry.mjs';
+import { detectChanges, getCurrentBranch, isValidClone } from '../git.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
 
 export function statusCommand(args) {
-  const cwd = process.cwd();
-  const workspaceDir = join(cwd, '.aw_registry');
+  const HOME = homedir();
+  const AW_HOME = join(HOME, '.aw');
+  const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 
-  const cfg = config.load(workspaceDir);
-  if (!cfg) {
-    fmt.cancel('No .sync-config.json found. Run: aw --init');
+  fmt.intro('aw status');
+
+  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  if (!isValidClone(AW_HOME, repoUrl)) {
+    fmt.cancel('Registry not initialized. Run: aw init');
+    return;
   }
 
-  const manifest = loadManifest(workspaceDir);
+  const cfg = config.load(GLOBAL_AW_DIR);
+  if (!cfg) {
+    fmt.cancel('No .sync-config.json found. Run: aw init');
+    return;
+  }
 
-  fmt.intro(`aw status`);
+  const branch = getCurrentBranch(AW_HOME);
+  const isOnMain = branch === 'main';
 
   // Info note
   const infoLines = [
-    `${chalk.dim('namespace:')}  ${cfg.namespace || 'none'}`,
+    `${chalk.dim('source:')}     ~/.aw/ (git clone)`,
+    `${chalk.dim('branch:')}     ${isOnMain ? chalk.dim(branch) : chalk.yellow(branch)}`,
+    cfg.namespace ? `${chalk.dim('namespace:')}  ${cfg.namespace}` : null,
     cfg.user ? `${chalk.dim('user:')}       ${cfg.user}` : null,
-    manifest.synced_at ? `${chalk.dim('last sync:')}  ${manifest.synced_at}` : null,
   ].filter(Boolean).join('\n');
   fmt.note(infoLines, 'Workspace');
 
   // Show synced paths
-  if (cfg.include.length > 0) {
+  if (cfg.include && cfg.include.length > 0) {
     const pathLines = cfg.include.map(p => `  ${chalk.cyan(p)}`).join('\n');
     fmt.note(pathLines, 'Synced Paths');
   } else {
-    fmt.logInfo('No paths synced. Run: aw pull <path>');
+    fmt.logInfo('No extra paths synced (platform/ always included).');
   }
 
-  const files = Object.entries(manifest.files || {});
-  const modified = [];
-  const unpushed = [];
-  const missing = [];
-  const conflicts = [];
-
-  for (const [key, entry] of files) {
-    const filePath = join(workspaceDir, key);
-    if (!existsSync(filePath)) {
-      missing.push(key);
-      continue;
-    }
-
-    const currentHash = hashFile(filePath);
-
-    // Template-derived files that were never pushed to the remote registry
-    if (!entry.registry_sha256) {
-      unpushed.push(key);
-      continue;
-    }
-
-    if (currentHash !== entry.sha256) {
-      const content = readFileSync(filePath, 'utf8');
-      if (content.includes('<<<<<<<')) {
-        conflicts.push(key);
-        continue;
-      }
-      modified.push(key);
-    }
-  }
+  // Git-native change detection
+  const changes = detectChanges(AW_HOME, REGISTRY_DIR);
+
+  const { modified, added, deleted, untracked } = changes;
+  const allNew = [...added, ...untracked];
 
   // Summary line
   const summaryParts = [
-    `${files.length} synced`,
-    unpushed.length > 0 ? chalk.green(`${unpushed.length} new (unpushed)`) : null,
     modified.length > 0 ? chalk.yellow(`${modified.length} modified`) : null,
-    conflicts.length > 0 ? chalk.red(`${conflicts.length} conflicts`) : null,
-    missing.length > 0 ? chalk.dim(`${missing.length} missing`) : null,
-  ].filter(Boolean).join(chalk.dim(' · '));
+    allNew.length > 0 ? chalk.green(`${allNew.length} new (unpushed)`) : null,
+    deleted.length > 0 ? chalk.dim(`${deleted.length} deleted`) : null,
+  ].filter(Boolean);
 
-  fmt.logInfo(summaryParts);
+  if (summaryParts.length === 0) {
+    fmt.logSuccess('Workspace is clean');
+  } else {
+    fmt.logInfo(summaryParts.join(chalk.dim(' · ')));
+  }
 
-  if (conflicts.length > 0) {
+  if (allNew.length > 0) {
     fmt.note(
-      conflicts.map(c => chalk.red(c)).join('\n'),
-      chalk.red('Unresolved Conflicts')
+      allNew.map(f => chalk.green(`  ${f.registryPath}`)).join('\n'),
+      chalk.green('New (unpushed)')
     );
   }
 
-  if (unpushed.length > 0) {
-    // Group by namespace for cleaner display
-    const nsCounts = {};
-    for (const key of unpushed) {
-      const ns = key.split('/').slice(0, 2).join('/');
-      nsCounts[ns] = (nsCounts[ns] || 0) + 1;
-    }
-    const nsLines = Object.entries(nsCounts).map(([ns, count]) => chalk.green(`  ${ns}: ${count} files`)).join('\n');
-    fmt.note(nsLines, chalk.green('New (unpushed)'));
-  }
-
   if (modified.length > 0) {
     fmt.note(
-      modified.map(m => chalk.yellow(m)).join('\n'),
+      modified.map(f => chalk.yellow(`  ${f.registryPath}`)).join('\n'),
       chalk.yellow('Modified')
     );
   }
 
-  if (missing.length > 0) {
+  if (deleted.length > 0) {
     fmt.note(
-      missing.map(m => chalk.dim(m)).join('\n'),
-      chalk.dim('Missing (deleted locally)')
+      deleted.map(f => chalk.dim(`  ${f.registryPath}`)).join('\n'),
+      chalk.dim('Deleted')
     );
   }
 
-  if (modified.length === 0 && conflicts.length === 0 && missing.length === 0 && unpushed.length === 0) {
-    fmt.logSuccess('Workspace is clean');
+  if (!isOnMain) {
+    fmt.logWarn(`On branch ${chalk.yellow(branch)} — run ${chalk.dim('aw pull')} to sync or checkout main first`);
   }
 
   // Hints
-  if (conflicts.length > 0) {
-    fmt.logWarn(`Fix conflicts: ${chalk.dim('grep -r "<<<<<<< " .aw_registry/')}`);
-  }
-  if (unpushed.length > 0) {
-    fmt.logInfo(`Push new files: ${chalk.dim('aw push')} or ${chalk.dim('aw push <namespace>')}`);
-  }
-  if (modified.length > 0) {
-    fmt.logInfo(`Push changes: ${chalk.dim('aw push <path>')}`);
+  if (allNew.length > 0 || modified.length > 0 || deleted.length > 0) {
+    fmt.logInfo(`Push changes: ${chalk.dim('aw push')} or ${chalk.dim('aw push <path>')}`);
   }
 
-  fmt.outro(`${chalk.dim('aw pull <pattern>')} to pull latest`);
+  fmt.outro(`${chalk.dim('aw pull')} to fetch latest`);
 }

package/config.mjs

@@ -48,7 +48,7 @@ export function create(workspaceDir, { namespace, user }) {
 
 export function addPattern(workspaceDir, pattern) {
   const config = load(workspaceDir);
-  if (!config) throw new Error('No .sync-config.json found. Run: aw --init --namespace <name>');
+  if (!config) throw new Error('No .sync-config.json found. Run: aw init');
   // If a parent path already covers this, skip
   if (config.include.some(p => pattern === p || pattern.startsWith(p + '/'))) {
     return config;
@@ -62,7 +62,7 @@ export function addPattern(workspaceDir, pattern) {
 
 export function removePattern(workspaceDir, pattern) {
   const config = load(workspaceDir);
-  if (!config) throw new Error('No .sync-config.json found. Run: aw --init --namespace <name>');
+  if (!config) throw new Error('No .sync-config.json found. Run: aw init');
   // Remove exact match + all children
   config.include = config.include.filter(p => p !== pattern && !p.startsWith(pattern + '/'));
   save(workspaceDir, config);

package/constants.mjs

@@ -1,5 +1,8 @@
 // constants.mjs — Single source of truth for registry settings.
 
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
 /** Base branch for PRs and sync checkout */
 export const REGISTRY_BASE_BRANCH = 'main';
 
@@ -11,3 +14,6 @@ export const REGISTRY_DIR = '.aw_registry';
 
 /** Directory in platform-docs repo containing documentation (pulled into platform/docs/) */
 export const DOCS_SOURCE_DIR = 'content';
+
+/** Persistent git clone root — ~/.aw/ */
+export const AW_HOME = join(homedir(), '.aw');

package/ecc.mjs

@@ -0,0 +1,180 @@
+import { execSync } from "node:child_process";
+import {
+  existsSync, readFileSync, readdirSync,
+  mkdirSync, rmSync, writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import * as fmt from "./fmt.mjs";
+
+const AW_ECC_REPO_SSH = "git@github.com:shreyansh-ghl/aw-ecc.git";
+const AW_ECC_REPO_HTTPS = "https://github.com/shreyansh-ghl/aw-ecc.git";
+const AW_ECC_TAG = "v1.2.2";
+
+const MARKETPLACE_NAME = "aw-marketplace";
+const PLUGIN_KEY = `aw@${MARKETPLACE_NAME}`;
+
+function eccDir() { return join(homedir(), ".aw-ecc"); }
+
+const FILE_COPY_TARGETS = ["cursor", "codex"];
+
+const TARGET_STATE = {
+  cursor: { state: ".cursor/ecc-install-state.json" },
+  codex:  { state: ".codex/ecc-install-state.json" },
+};
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { stdio: "pipe", ...opts });
+}
+
+function cloneOrUpdate(tag, dest) {
+  if (existsSync(join(dest, ".git"))) {
+    try {
+      run(`git -C ${dest} fetch --quiet --depth 1 origin tag ${tag}`);
+      run(`git -C ${dest} checkout --quiet ${tag}`);
+      return;
+    } catch { /* fall through to fresh clone */ }
+  }
+  if (existsSync(dest)) rmSync(dest, { recursive: true, force: true });
+  try {
+    run(`git clone --quiet --depth 1 --branch ${tag} ${AW_ECC_REPO_SSH} ${dest}`);
+  } catch {
+    run(`git clone --quiet --depth 1 --branch ${tag} ${AW_ECC_REPO_HTTPS} ${dest}`);
+  }
+}
+
+function installClaudePlugin(repoDir) {
+  try {
+    run(`claude plugin marketplace add ${repoDir} --scope user`);
+  } catch {
+    try { run(`claude plugin marketplace update ${MARKETPLACE_NAME}`); } catch { /* ok */ }
+  }
+  run(`claude plugin install ${PLUGIN_KEY} --scope user`);
+}
+
+function uninstallClaudePlugin() {
+  try { run(`claude plugin uninstall ${PLUGIN_KEY} --scope user`); } catch { /* not installed */ }
+  try { run(`claude plugin marketplace remove ${MARKETPLACE_NAME}`); } catch { /* not registered */ }
+}
+
+export async function installAwEcc(
+  cwd,
+  { targets = ["cursor", "claude", "codex"], silent = false } = {},
+) {
+  if (!silent) fmt.logStep("Installing aw-ecc engine...");
+
+  const repoDir = eccDir();
+
+  try {
+    cloneOrUpdate(AW_ECC_TAG, repoDir);
+
+    // Claude Code: plugin install via marketplace CLI (proper agent dispatch)
+    if (targets.includes("claude")) {
+      try {
+        installClaudePlugin(repoDir);
+      } catch (err) {
+        if (!silent) fmt.logWarn(`Claude plugin install skipped: ${err.message}`);
+      }
+    }
+
+    // Cursor + Codex: file-copy via install-apply.js
+    const fileCopyTargets = targets.filter((t) => FILE_COPY_TARGETS.includes(t));
+    if (fileCopyTargets.length > 0) {
+      run("npm install --no-audit --no-fund --ignore-scripts --loglevel=error", {
+        cwd: repoDir,
+      });
+      for (const target of fileCopyTargets) {
+        try {
+          run(
+            `node ${join(repoDir, "scripts/install-apply.js")} --target ${target} --profile full`,
+            { cwd },
+          );
+        } catch { /* target not supported — skip */ }
+      }
+    }
+
+    if (!silent) fmt.logSuccess("aw-ecc engine installed");
+  } catch (err) {
+    if (!silent) fmt.logWarn(`aw-ecc install failed: ${err.message}`);
+  }
+}
+
+export function uninstallAwEcc({ silent = false } = {}) {
+  const HOME = homedir();
+  let removed = 0;
+
+  // Claude Code: uninstall plugin + remove marketplace via CLI
+  try {
+    uninstallClaudePlugin();
+    removed++;
+  } catch { /* best effort */ }
+
+  // Cursor + Codex: remove file-copied content via install-state
+  for (const cfg of Object.values(TARGET_STATE)) {
+    const statePath = join(HOME, cfg.state);
+    if (!existsSync(statePath)) continue;
+
+    try {
+      const data = JSON.parse(readFileSync(statePath, "utf8"));
+      for (const op of data.operations || []) {
+        if (op.destinationPath && existsSync(op.destinationPath)) {
+          rmSync(op.destinationPath, { recursive: true, force: true });
+          removed++;
+          pruneEmptyParents(op.destinationPath, join(HOME, cfg.state.split("/")[0]));
+        }
+      }
+      rmSync(statePath, { force: true });
+      pruneEmptyParents(statePath, join(HOME, cfg.state.split("/")[0]));
+    } catch { /* corrupted state — skip */ }
+  }
+
+  // Clean leftover claude install-state from older file-copy versions
+  const claudeState = join(HOME, ".claude", "ecc", "install-state.json");
+  if (existsSync(claudeState)) {
+    try {
+      const data = JSON.parse(readFileSync(claudeState, "utf8"));
+      for (const op of data.operations || []) {
+        if (op.destinationPath && existsSync(op.destinationPath)) {
+          rmSync(op.destinationPath, { recursive: true, force: true });
+          removed++;
+        }
+      }
+      rmSync(claudeState, { force: true });
+      pruneEmptyParents(claudeState, join(HOME, ".claude"));
+    } catch { /* best effort */ }
+  }
+
+  // Clean leftover manual plugin cache from older versions
+  const oldCache = join(HOME, ".claude", "plugins", "cache", "aw");
+  if (existsSync(oldCache)) {
+    rmSync(oldCache, { recursive: true, force: true });
+    removed++;
+  }
+
+  // Remove permanent aw-ecc repo clone
+  const repoDir = eccDir();
+  if (existsSync(repoDir)) {
+    rmSync(repoDir, { recursive: true, force: true });
+    removed++;
+  }
+
+  if (!silent && removed > 0)
+    fmt.logStep(`Removed ${removed} aw-ecc file${removed > 1 ? "s" : ""}`);
+  return removed;
+}
+
+function pruneEmptyParents(filePath, stopAt) {
+  let dir = dirname(filePath);
+  while (dir !== stopAt && dir.startsWith(stopAt)) {
+    try {
+      if (readdirSync(dir).length === 0) {
+        rmSync(dir);
+        dir = dirname(dir);
+      } else {
+        break;
+      }
+    } catch {
+      break;
+    }
+  }
+}

package/fmt.mjs

@@ -36,6 +36,8 @@ export function banner(text, opts = {}) {
 export const intro    = (msg) => p.intro(chalk.bgCyan.black(` ${msg} `));
 export const outro    = (msg) => p.outro(chalk.green(msg));
 export const spinner  = () => p.spinner();
+export const select   = p.select;
+export const isCancel = p.isCancel;
 
 export function cancel(msg) {
   p.cancel(msg);

package/git.mjs

@@ -1,4 +1,4 @@
-// git.mjs — Git sparse checkout helpers. Zero dependencies.
+// git.mjs — Git helpers: sparse checkout (temp) + persistent clone operations.
 
 import { execSync, exec as execCb } from 'node:child_process';
 import { mkdtempSync, existsSync } from 'node:fs';
@@ -9,6 +9,8 @@ import { REGISTRY_BASE_BRANCH, REGISTRY_DIR, DOCS_SOURCE_DIR } from './constants
 
 const exec = promisify(execCb);
 
+// ── Backward-compat: temp-dir sparse checkout (used by search.mjs) ────────────
+
 /**
  * Sparse-checkout registry paths from GitHub (sync).
  * Returns the temp directory path containing the checkout.
@@ -92,3 +94,233 @@ export function includeToSparsePaths(paths) {
   }
   return [...result];
 }
+
+// ── Persistent clone operations ────────────────────────────────────────────────
+
+/**
+ * Check if awHome is already a valid git clone of the given registry repo.
+ * Returns boolean.
+ */
+export function isValidClone(awHome, repoUrl) {
+  if (!existsSync(join(awHome, '.git'))) return false;
+  try {
+    const remote = execSync('git remote get-url origin', { cwd: awHome, stdio: 'pipe', encoding: 'utf8' }).trim();
+    return remote === repoUrl || remote === repoUrl.replace(/\.git$/, '') + '.git' || remote.replace(/\.git$/, '') === repoUrl.replace(/\.git$/, '');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Initialize a persistent clone with sparse checkout at awHome.
+ * sparsePaths: array of repo-relative paths to include (e.g. ['.aw_registry/platform', 'content'])
+ */
+export function initPersistentClone(repoUrl, awHome, sparsePaths) {
+  try {
+    execSync(`git clone --filter=blob:none --no-checkout "${repoUrl}" "${awHome}"`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to clone ${repoUrl}: ${e.message}`);
+  }
+
+  try {
+    execSync('git sparse-checkout init --cone', { cwd: awHome, stdio: 'pipe' });
+    execSync(`git sparse-checkout set ${sparsePaths.map(p => `"${p}"`).join(' ')}`, { cwd: awHome, stdio: 'pipe' });
+    execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: awHome, stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to configure sparse checkout: ${e.message}`);
+  }
+}
+
+/**
+ * Add paths to an existing sparse checkout.
+ * Merges with currently checked-out paths.
+ */
+export function addToSparseCheckout(awHome, newPaths) {
+  let existing = [];
+  try {
+    const out = execSync('git sparse-checkout list', { cwd: awHome, stdio: 'pipe', encoding: 'utf8' });
+    existing = out.trim().split('\n').filter(Boolean);
+  } catch {
+    // no sparse-checkout set yet — start fresh
+  }
+
+  const combined = [...new Set([...existing, ...newPaths])];
+  try {
+    execSync(`git sparse-checkout set ${combined.map(p => `"${p}"`).join(' ')}`, { cwd: awHome, stdio: 'pipe' });
+    execSync(`git checkout ${REGISTRY_BASE_BRANCH}`, { cwd: awHome, stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to add to sparse checkout: ${e.message}`);
+  }
+}
+
+/**
+ * Remove paths from an existing sparse checkout.
+ * Remaining paths stay checked out.
+ */
+export function removeFromSparseCheckout(awHome, removePaths) {
+  let existing = [];
+  try {
+    const out = execSync('git sparse-checkout list', { cwd: awHome, stdio: 'pipe', encoding: 'utf8' });
+    existing = out.trim().split('\n').filter(Boolean);
+  } catch {
+    return; // nothing to remove
+  }
+
+  const removeSet = new Set(removePaths);
+  const remaining = existing.filter(p => !removeSet.has(p));
+
+  try {
+    if (remaining.length > 0) {
+      execSync(`git sparse-checkout set ${remaining.map(p => `"${p}"`).join(' ')}`, { cwd: awHome, stdio: 'pipe' });
+    } else {
+      // Disable sparse checkout entirely
+      execSync('git sparse-checkout disable', { cwd: awHome, stdio: 'pipe' });
+    }
+  } catch (e) {
+    throw new Error(`Failed to remove from sparse checkout: ${e.message}`);
+  }
+}
+
+/**
+ * Fetch and merge latest from origin/main into the persistent clone.
+ * Returns { updated: boolean, conflicts: string[] }
+ */
+export function fetchAndMerge(awHome) {
+  try {
+    execSync(`git -C "${awHome}" fetch origin ${REGISTRY_BASE_BRANCH}`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to fetch from origin: ${e.message}`);
+  }
+
+  let updated = false;
+  const conflicts = [];
+
+  try {
+    const result = execSync(`git -C "${awHome}" merge origin/${REGISTRY_BASE_BRANCH} --ff-only`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+    updated = !result.includes('Already up to date');
+  } catch {
+    // ff-only failed — try no-edit merge
+    try {
+      execSync(`git -C "${awHome}" merge origin/${REGISTRY_BASE_BRANCH} --no-edit`, {
+        stdio: 'pipe',
+        encoding: 'utf8',
+      });
+      updated = true;
+    } catch (mergeErr) {
+      // Parse conflicts
+      try {
+        const statusOut = execSync(`git -C "${awHome}" diff --name-only --diff-filter=U`, {
+          stdio: 'pipe',
+          encoding: 'utf8',
+        });
+        conflicts.push(...statusOut.trim().split('\n').filter(Boolean));
+      } catch { /* best effort */ }
+    }
+  }
+
+  return { updated, conflicts };
+}
+
+/**
+ * Detect local changes in registryDir/ within awHome.
+ * Returns { modified: [], added: [], deleted: [], untracked: [] }
+ * Each entry: { path: 'relative/to/awHome', registryPath: 'relative/to/registryDir' }
+ */
+export function detectChanges(awHome, registryDir) {
+  let statusOut = '';
+  try {
+    statusOut = execSync(`git -C "${awHome}" status --porcelain "${registryDir}/"`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+  } catch {
+    return { modified: [], added: [], deleted: [], untracked: [] };
+  }
+
+  const modified = [];
+  const added = [];
+  const deleted = [];
+  const untracked = [];
+
+  for (const line of statusOut.split('\n')) {
+    if (!line || line.length < 3) continue;
+    const xy = line.slice(0, 2);
+    const filePath = line.slice(3).trim();
+    const registryPath = filePath.startsWith(registryDir + '/') ? filePath.slice(registryDir.length + 1) : filePath;
+    const entry = { path: filePath, registryPath };
+
+    if (xy === '??') {
+      untracked.push(entry);
+    } else if (xy[0] === 'D' || xy[1] === 'D') {
+      deleted.push(entry);
+    } else if (xy[0] === 'A' || xy[1] === 'A') {
+      added.push(entry);
+    } else if (xy[0] === 'M' || xy[1] === 'M') {
+      modified.push(entry);
+    }
+  }
+
+  return { modified, added, deleted, untracked };
+}
+
+/**
+ * Create a branch, stage files, commit, push to origin.
+ * Branch stays on disk for iteration.
+ * Returns the branch name.
+ */
+export function createPushBranch(awHome, branchName, files, commitMsg) {
+  try {
+    execSync(`git -C "${awHome}" checkout -b "${branchName}"`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to create branch ${branchName}: ${e.message}`);
+  }
+
+  try {
+    const quotedFiles = files.map(f => `"${f}"`).join(' ');
+    execSync(`git -C "${awHome}" add ${quotedFiles}`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to stage files: ${e.message}`);
+  }
+
+  try {
+    execSync(`git -C "${awHome}" commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to commit: ${e.message}`);
+  }
+
+  try {
+    execSync(`git -C "${awHome}" push -u origin "${branchName}"`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to push branch: ${e.message}`);
+  }
+
+  return branchName;
+}
+
+/**
+ * Get the current branch name in awHome.
+ */
+export function getCurrentBranch(awHome) {
+  try {
+    return execSync(`git -C "${awHome}" rev-parse --abbrev-ref HEAD`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Checkout the main branch in awHome.
+ */
+export function checkoutMain(awHome) {
+  try {
+    execSync(`git -C "${awHome}" checkout ${REGISTRY_BASE_BRANCH}`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error(`Failed to checkout ${REGISTRY_BASE_BRANCH}: ${e.message}`);
+  }
+}